occam-verify-cli 1.0.421 → 1.0.428

package/lib/element/term.js

@@ -0,0 +1,322 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: Object.getOwnPropertyDescriptor(all, name).get
+    });
+}
+_export(exports, {
+    get default () {
+        return _default;
+    },
+    get variablesFromTerm () {
+        return variablesFromTerm;
+    }
+});
+var _necessary = require("necessary");
+var _elements = /*#__PURE__*/ _interop_require_wildcard(require("../elements"));
+var _verify = /*#__PURE__*/ _interop_require_default(require("../mixins/term/verify"));
+var _instantiate = require("../process/instantiate");
+var _nodeold = require("../utilities/node.old");
+var _json = require("../utilities/json");
+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 _Term;
+var filter = _necessary.arrayUtilities.filter, compress = _necessary.arrayUtilities.compress;
+var _default = (0, _elements.define)((_Term = /*#__PURE__*/ function() {
+    function Term(string, node, type) {
+        _class_call_check(this, Term);
+        this.string = string;
+        this.node = node;
+        this.type = type;
+    }
+    _create_class(Term, [
+        {
+            key: "getString",
+            value: function getString() {
+                return this.string;
+            }
+        },
+        {
+            key: "getNode",
+            value: function getNode() {
+                return this.node;
+            }
+        },
+        {
+            key: "getType",
+            value: function getType() {
+                return this.type;
+            }
+        },
+        {
+            key: "setType",
+            value: function setType(type) {
+                this.type = type;
+            }
+        },
+        {
+            key: "isSingular",
+            value: function isSingular() {
+                return this.node.isSingular();
+            }
+        },
+        {
+            key: "isProvisional",
+            value: function isProvisional() {
+                return this.type.isProvisional();
+            }
+        },
+        {
+            key: "matchTermNode",
+            value: function matchTermNode(termNode) {
+                return this.node.match(termNode);
+            }
+        },
+        {
+            key: "isEqualToVariable",
+            value: function isEqualToVariable(variable) {
+                var variableNodeMathces = false;
+                var singular = this.isSingular();
+                if (singular) {
+                    var variableNode = variable.getNode(), singularVariableNode = this.node.getSingularVariableNode(), variableNodeA = variableNode, variableNodeB = singularVariableNode, matches = variableNodeA.match(variableNodeB);
+                    if (matches) {
+                        variableNodeMathces = true;
+                    }
+                }
+                return variableNodeMathces;
+            }
+        },
+        {
+            key: "isEqualTo",
+            value: function isEqualTo(term) {
+                var termNode = term.getNode(), matches = this.node.match(termNode), equalTo = matches; ///
+                return equalTo;
+            }
+        },
+        {
+            key: "isGrounded",
+            value: function isGrounded(definedVariables, context) {
+                var term = this, variables = variablesFromTerm(term, context);
+                filter(variables, function(variable) {
+                    var definedVariablesIncludesVariable = definedVariables.includes(variable);
+                    if (!definedVariablesIncludesVariable) {
+                        return true;
+                    }
+                });
+                var undefinedVariables = variables, undefinedVariablesLength = undefinedVariables.length, grounded = undefinedVariablesLength <= 1;
+                return grounded;
+            }
+        },
+        {
+            key: "isInitiallyGrounded",
+            value: function isInitiallyGrounded(context) {
+                var term = this, variables = variablesFromTerm(term, context), variablesLength = variables.length, initiallyGrounded = variablesLength === 0;
+                return initiallyGrounded;
+            }
+        },
+        {
+            key: "isImplicitlyGrounded",
+            value: function isImplicitlyGrounded(definedVariables, context) {
+                var grounded = this.isGrounded(definedVariables, context), implicitlyGrounded = grounded; ///
+                return implicitlyGrounded;
+            }
+        },
+        {
+            key: "verify",
+            value: function verify(context, verifyAhead) {
+                var _this = this;
+                var verifies;
+                var termString = this.string; ///
+                context.trace("Verifying the '".concat(termString, "' term..."));
+                verifies = _verify.default.some(function(verifyMixin) {
+                    var term = _this, verifies = verifyMixin(term, context, verifyAhead);
+                    if (verifies) {
+                        return true;
+                    }
+                });
+                if (verifies) {
+                    var term = this; ///
+                    context.addTerm(term);
+                    context.debug("...verified the '".concat(termString, "' term."));
+                }
+                return verifies;
+            }
+        },
+        {
+            key: "verifyGivenType",
+            value: function verifyGivenType(type, generalContext, specificContext) {
+                var _this = this;
+                var verifiesGivenType;
+                var typeString = type.getString(), termString = this.getString(); ///
+                specificContext.trace("Verifying the '".concat(termString, "' term given the '").concat(typeString, "' type..."));
+                var context = specificContext, verifies = this.verify(context, function() {
+                    var verifiesAhead;
+                    var typeEqualToOrSubTypeOfGivenTypeType = _this.type.isEqualToOrSubTypeOf(type);
+                    if (typeEqualToOrSubTypeOfGivenTypeType) {
+                        verifiesAhead = true;
+                    }
+                    return verifiesAhead;
+                });
+                verifiesGivenType = verifies; ///
+                if (verifiesGivenType) {
+                    specificContext.debug("...verified the '".concat(termString, "' term given the '").concat(typeString, "' type."));
+                }
+                return verifiesGivenType;
+            }
+        },
+        {
+            key: "toJSON",
+            value: function toJSON() {
+                var typeJSON = (0, _json.typeToTypeJSON)(this.type), string = this.string, type = typeJSON, json = {
+                    type: type,
+                    string: string
+                };
+                return json;
+            }
+        }
+    ], [
+        {
+            key: "fromJSON",
+            value: function fromJSON(json, context) {
+                var string = json.string, termNode = (0, _instantiate.instantiateTerm)(string, context), node = termNode, type = (0, _json.typeFromJSON)(json, context), term = new Term(string, node, type);
+                return term;
+            }
+        },
+        {
+            key: "fromTermNode",
+            value: function fromTermNode(termNode, context) {
+                var term = (0, _nodeold.termFromTermNode)(termNode, context);
+                return term;
+            }
+        },
+        {
+            key: "fromTermNodeAndType",
+            value: function fromTermNodeAndType(termNode, type, context) {
+                var node = termNode, string = context.nodeAsString(node), term = new Term(string, node, type);
+                return term;
+            }
+        },
+        {
+            key: "fromDefinedAssertionNode",
+            value: function fromDefinedAssertionNode(definedAssertionNode, context) {
+                var term = null;
+                var termNode = definedAssertionNode.getTermNode();
+                if (termNode !== null) {
+                    term = (0, _nodeold.termFromTermNode)(termNode, context);
+                }
+                return term;
+            }
+        },
+        {
+            key: "fromPropertyRelationNode",
+            value: function fromPropertyRelationNode(propertyRelationNode, context) {
+                var termNode = propertyRelationNode.getTermNode(), term = (0, _nodeold.termFromTermNode)(termNode, context);
+                return term;
+            }
+        },
+        {
+            key: "fromConstructorDeclarationNode",
+            value: function fromConstructorDeclarationNode(constructorDeclarationNode, context) {
+                var Type = _elements.default.Type, termNode = constructorDeclarationNode.getTermNode(), term = (0, _nodeold.termFromTermNode)(termNode, context), type = Type.fromConstructorDeclarationNode(constructorDeclarationNode, context);
+                term.setType(type);
+                return term;
+            }
+        }
+    ]);
+    return Term;
+}(), _define_property(_Term, "name", "Term"), _Term));
+function variablesFromTerm(term, context) {
+    var termNode = term.getNode(), variableNodes = termNode.getVariableNodes(), variables = variableNodes.map(function(variableNode) {
+        var variableIdentifier = variableNode.getVariableIdentifier(), variable = context.findVariableByVariableIdentifier(variableIdentifier);
+        return variable;
+    });
+    compress(variables, function(variableA, variableB) {
+        var variableAEqualToVariableB = variableA.isEqualTo(variableB);
+        if (!variableAEqualToVariableB) {
+            return true;
+        }
+    });
+    return variables;
+}
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../src/element/term.js"],"sourcesContent":["\"use strict\";\n\nimport { arrayUtilities } from \"necessary\";\n\nimport elements from \"../elements\";\nimport verifyMixins from \"../mixins/term/verify\";\n\nimport { define } from \"../elements\";\nimport { instantiateTerm } from \"../process/instantiate\";\nimport { termFromTermNode } from \"../utilities/node.old\";\nimport { typeFromJSON, typeToTypeJSON } from \"../utilities/json\";\n\nconst { filter, compress } = arrayUtilities;\n\nexport default define(class Term {\n  constructor(string, node, type) {\n    this.string = string;\n    this.node = node;\n    this.type = type;\n  }\n\n  getString() {\n    return this.string;\n  }\n\n  getNode() {\n    return this.node;\n  }\n\n  getType() {\n    return this.type;\n  }\n\n  setType(type) {\n    this.type = type;\n  }\n\n  isSingular() { return this.node.isSingular(); }\n\n  isProvisional() { return this.type.isProvisional(); }\n\n  matchTermNode(termNode) { return this.node.match(termNode); }\n\n  isEqualToVariable(variable) {\n    let variableNodeMathces = false;\n\n    const singular = this.isSingular();\n\n    if (singular) {\n      const variableNode = variable.getNode(),\n            singularVariableNode = this.node.getSingularVariableNode(),\n            variableNodeA = variableNode, ///\n            variableNodeB = singularVariableNode, ///\n            matches = variableNodeA.match(variableNodeB);\n\n      if (matches) {\n        variableNodeMathces = true;\n      }\n    }\n\n    return variableNodeMathces;\n  }\n\n  isEqualTo(term) {\n    const termNode = term.getNode(),\n          matches = this.node.match(termNode),\n          equalTo = matches;  ///\n\n    return equalTo;\n  }\n\n  isGrounded(definedVariables, context) {\n    const term  = this, ///\n          variables = variablesFromTerm(term, context);\n\n    filter(variables, (variable) => {\n      const definedVariablesIncludesVariable = definedVariables.includes(variable);\n\n      if (!definedVariablesIncludesVariable) {\n        return true;\n      }\n    });\n\n    const undefinedVariables = variables, ///\n          undefinedVariablesLength = undefinedVariables.length,\n          grounded = (undefinedVariablesLength <= 1);\n\n    return grounded;\n  }\n\n  isInitiallyGrounded(context) {\n    const term  = this, ///\n          variables = variablesFromTerm(term, context),\n          variablesLength = variables.length,\n          initiallyGrounded = (variablesLength === 0);\n\n    return initiallyGrounded;\n  }\n\n  isImplicitlyGrounded(definedVariables, context) {\n    const grounded = this.isGrounded(definedVariables, context),\n          implicitlyGrounded = grounded;  ///\n\n    return implicitlyGrounded;\n  }\n\n  verify(context, verifyAhead) {\n    let verifies;\n\n    const termString = this.string;  ///\n\n    context.trace(`Verifying the '${termString}' term...`);\n\n    verifies = verifyMixins.some((verifyMixin) => {\n      const term = this, ///\n            verifies = verifyMixin(term, context, verifyAhead);\n\n      if (verifies) {\n        return true;\n      }\n    });\n\n    if (verifies) {\n      const term = this;  ///\n\n      context.addTerm(term);\n\n      context.debug(`...verified the '${termString}' term.`);\n    }\n\n    return verifies;\n  }\n\n  verifyGivenType(type, generalContext, specificContext) {\n    let verifiesGivenType;\n\n    const typeString = type.getString(),\n          termString = this.getString();  ///\n\n    specificContext.trace(`Verifying the '${termString}' term given the '${typeString}' type...`);\n\n    const context = specificContext, ///\n          verifies = this.verify(context, () => {\n            let verifiesAhead;\n\n            const typeEqualToOrSubTypeOfGivenTypeType = this.type.isEqualToOrSubTypeOf(type);\n\n            if (typeEqualToOrSubTypeOfGivenTypeType) {\n              verifiesAhead = true;\n            }\n\n            return verifiesAhead;\n          });\n\n    verifiesGivenType = verifies; ///\n\n    if (verifiesGivenType) {\n      specificContext.debug(`...verified the '${termString}' term given the '${typeString}' type.`);\n    }\n\n    return verifiesGivenType;\n  }\n\n  toJSON() {\n    const typeJSON = typeToTypeJSON(this.type),\n          string = this.string, ///\n          type = typeJSON,  ///\n          json = {\n            type,\n            string\n          };\n\n    return json;\n  }\n\n  static name = \"Term\";\n\n  static fromJSON(json, context) {\n    const { string } = json,\n          termNode = instantiateTerm(string, context),\n          node = termNode,  ///\n          type = typeFromJSON(json, context),\n          term = new Term(string, node, type);\n\n    return term;\n  }\n\n  static fromTermNode(termNode, context) {\n    const term = termFromTermNode(termNode, context);\n\n    return term;\n  }\n\n  static fromTermNodeAndType(termNode, type, context) {\n    const node = termNode,  ///\n          string = context.nodeAsString(node),\n          term = new Term(string, node, type);\n\n    return term;\n  }\n\n  static fromDefinedAssertionNode(definedAssertionNode, context) {\n    let term = null;\n\n    const termNode = definedAssertionNode.getTermNode();\n\n    if (termNode !== null) {\n      term = termFromTermNode(termNode, context);\n    }\n\n    return term;\n  }\n\n  static fromPropertyRelationNode(propertyRelationNode, context) {\n    const termNode = propertyRelationNode.getTermNode(),\n          term = termFromTermNode(termNode, context);\n\n    return term;\n  }\n\n  static fromConstructorDeclarationNode(constructorDeclarationNode, context) {\n    const { Type } = elements,\n          termNode = constructorDeclarationNode.getTermNode(),\n          term = termFromTermNode(termNode, context),\n          type = Type.fromConstructorDeclarationNode(constructorDeclarationNode, context);\n\n    term.setType(type);\n\n    return term;\n  }\n});\n\nexport function variablesFromTerm(term, context) {\n  const termNode = term.getNode(),\n        variableNodes = termNode.getVariableNodes(),\n        variables = variableNodes.map((variableNode) => {\n          const variableIdentifier = variableNode.getVariableIdentifier(),\n                variable = context.findVariableByVariableIdentifier(variableIdentifier);\n\n          return variable;\n        });\n\n  compress(variables, (variableA, variableB) => {\n    const variableAEqualToVariableB = variableA.isEqualTo(variableB);\n\n    if (!variableAEqualToVariableB) {\n      return true;\n    }\n  });\n\n  return variables;\n}\n\n"],"names":["variablesFromTerm","filter","arrayUtilities","compress","define","Term","string","node","type","getString","getNode","getType","setType","isSingular","isProvisional","matchTermNode","termNode","match","isEqualToVariable","variable","variableNodeMathces","singular","variableNode","singularVariableNode","getSingularVariableNode","variableNodeA","variableNodeB","matches","isEqualTo","term","equalTo","isGrounded","definedVariables","context","variables","definedVariablesIncludesVariable","includes","undefinedVariables","undefinedVariablesLength","length","grounded","isInitiallyGrounded","variablesLength","initiallyGrounded","isImplicitlyGrounded","implicitlyGrounded","verify","verifyAhead","verifies","termString","trace","verifyMixins","some","verifyMixin","addTerm","debug","verifyGivenType","generalContext","specificContext","verifiesGivenType","typeString","verifiesAhead","typeEqualToOrSubTypeOfGivenTypeType","isEqualToOrSubTypeOf","toJSON","typeJSON","typeToTypeJSON","json","fromJSON","instantiateTerm","typeFromJSON","fromTermNode","termFromTermNode","fromTermNodeAndType","nodeAsString","fromDefinedAssertionNode","definedAssertionNode","getTermNode","fromPropertyRelationNode","propertyRelationNode","fromConstructorDeclarationNode","constructorDeclarationNode","Type","elements","name","variableNodes","getVariableNodes","map","variableIdentifier","getVariableIdentifier","findVariableByVariableIdentifier","variableA","variableB","variableAEqualToVariableB"],"mappings":"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"}

package/lib/{ontology → element}/theorem.js

@@ -8,8 +8,8 @@ Object.defineProperty(exports, "default", {
         return _default;
     }
 });
-var _topLevelAssertion = /*#__PURE__*/ _interop_require_default(require("./topLevelAssertion"));
-var _ontology = require("../ontology");
+var _axiomLemmaTheoremConjecture = /*#__PURE__*/ _interop_require_default(require("./axiomLemmaTheoremConjecture"));
+var _elements = require("../elements");
 function _assert_this_initialized(self) {
     if (self === void 0) {
         throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
@@ -125,8 +125,8 @@ function _is_native_reflect_construct() {
     })();
 }
 var _Theorem;
-var _default = (0, _ontology.define)((_Theorem = /*#__PURE__*/ function(TopLevelAssertion) {
-    _inherits(Theorem, TopLevelAssertion);
+var _default = (0, _elements.define)((_Theorem = /*#__PURE__*/ function(AxiomLemmaTheoremConjecture) {
+    _inherits(Theorem, AxiomLemmaTheoremConjecture);
     function Theorem() {
         _class_call_check(this, Theorem);
         return _call_super(this, Theorem, arguments);
@@ -151,18 +151,18 @@ var _default = (0, _ontology.define)((_Theorem = /*#__PURE__*/ function(TopLevel
         {
             key: "fromJSON",
             value: function fromJSON(json, context) {
-                return _topLevelAssertion.default.fromJSON(Theorem, json, context);
+                return _axiomLemmaTheoremConjecture.default.fromJSON(Theorem, json, context);
             }
         },
         {
             key: "fromTheoremNode",
             value: function fromTheoremNode(theoremNode, context) {
-                var node = theoremNode, theorem = _topLevelAssertion.default.fromNode(Theorem, node, context);
+                var node = theoremNode, theorem = _axiomLemmaTheoremConjecture.default.fromNode(Theorem, node, context);
                 return theorem;
             }
         }
     ]);
     return Theorem;
-}(_topLevelAssertion.default), _define_property(_Theorem, "name", "Theorem"), _Theorem));
+}(_axiomLemmaTheoremConjecture.default), _define_property(_Theorem, "name", "Theorem"), _Theorem));
 
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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