occam-verify-cli 1.0.448 → 1.0.457

package/lib/context/scoped.js

@@ -0,0 +1,314 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return _default;
+    }
+});
+var _necessary = require("necessary");
+var _elements = /*#__PURE__*/ _interop_require_default(require("../elements"));
+var _context = require("../utilities/context");
+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 _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+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 last = _necessary.arrayUtilities.last;
+var ScopedContext = /*#__PURE__*/ function() {
+    function ScopedContext(context, variables, judgements, equivalences, subproofOrProofAssertions) {
+        _class_call_check(this, ScopedContext);
+        this.context = context;
+        this.variables = variables;
+        this.judgements = judgements;
+        this.equivalences = equivalences;
+        this.subproofOrProofAssertions = subproofOrProofAssertions;
+        return (0, _context.chainContext)(this);
+    }
+    _create_class(ScopedContext, [
+        {
+            key: "getContext",
+            value: function getContext() {
+                return this.context;
+            }
+        },
+        {
+            key: "getVariables",
+            value: function getVariables() {
+                var nested = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : true;
+                var variables;
+                if (nested) {
+                    variables = this.context.getVariables();
+                    variables = _to_consumable_array(this.variables).concat(_to_consumable_array(variables));
+                } else {
+                    variables = this.variables;
+                }
+                return variables;
+            }
+        },
+        {
+            key: "getJudgements",
+            value: function getJudgements() {
+                var judgements = this.context.getJudgements();
+                judgements = _to_consumable_array(this.judgements).concat(_to_consumable_array(judgements));
+                return judgements;
+            }
+        },
+        {
+            key: "getEquivalences",
+            value: function getEquivalences() {
+                var equivalences = this.context.getEquivalences();
+                equivalences = this.equivalences.mergedWith(equivalences); ///
+                return equivalences;
+            }
+        },
+        {
+            key: "getProofAssertions",
+            value: function getProofAssertions() {
+                var subproofOrProofAssertions = this.getSubproofOrProofAssertions(), proofAssertions = subproofOrProofAssertions.filter(function(subproofOrProofAssertion) {
+                    var subproofOrProofAssertionproofAssertion = subproofOrProofAssertion.isProofAssertion();
+                    if (subproofOrProofAssertionproofAssertion) {
+                        return true;
+                    }
+                });
+                return proofAssertions;
+            }
+        },
+        {
+            key: "getLastProofAssertion",
+            value: function getLastProofAssertion() {
+                var lastProofAssertion = null;
+                var proofAssertions = this.getProofAssertions(), proofAssertionsLength = proofAssertions.length;
+                if (proofAssertionsLength > 0) {
+                    lastProofAssertion = last(proofAssertions);
+                }
+                return lastProofAssertion;
+            }
+        },
+        {
+            key: "getSubproofOrProofAssertions",
+            value: function getSubproofOrProofAssertions() {
+                var subproofOrProofAssertions = this.context.getSubproofOrProofAssertions();
+                subproofOrProofAssertions = _to_consumable_array(subproofOrProofAssertions).concat(_to_consumable_array(this.subproofOrProofAssertions));
+                return subproofOrProofAssertions;
+            }
+        },
+        {
+            key: "addEquality",
+            value: function addEquality(equality) {
+                var equalityAdded;
+                var equalityReflexive = equality.isReflexive();
+                if (!equalityReflexive) {
+                    var Equivalence = _elements.default.Equivalence, equivalence = Equivalence.fromEquality(equality), context = this; ///
+                    this.equivalences = this.equivalences.mergedWithEquivalence(equivalence, context);
+                }
+                equalityAdded = true;
+                if (equalityAdded) {
+                    var context1 = this, equalityString = equality.getString();
+                    context1.trace("Added the '".concat(equalityString, "' equality."));
+                }
+                return equalityAdded;
+            }
+        },
+        {
+            key: "addVariable",
+            value: function addVariable(variable) {
+                var nested = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : true;
+                var variableAdded = false;
+                var variableIdentifier = variable.getIdentifier(), variablePresent = this.isVariablePresentByVariableIdentifier(variableIdentifier, nested);
+                if (!variablePresent) {
+                    this.variables.push(variable);
+                    variableAdded = true;
+                }
+                if (variableAdded) {
+                    var context = this, variableString = variable.getString();
+                    context.trace("Added the '".concat(variableString, "' variable."));
+                }
+                return variableAdded;
+            }
+        },
+        {
+            key: "addJudgement",
+            value: function addJudgement(judgement) {
+                var judgementAdded = false;
+                var metavariable = judgement.getMetavariable(), judgementPresent = this.isJudgementPresentByMetavariable(metavariable);
+                if (!judgementPresent) {
+                    this.judgements.push(judgement);
+                    judgementAdded = true;
+                }
+                if (judgementAdded) {
+                    var context = this, judgementString = judgement.getString();
+                    context.trace("Added the '".concat(judgementString, "' judgement."));
+                }
+                return judgementAdded;
+            }
+        },
+        {
+            key: "addSubproofOrProofAssertion",
+            value: function addSubproofOrProofAssertion(subproofOrProofAssertion) {
+                this.subproofOrProofAssertions.push(subproofOrProofAssertion);
+            }
+        },
+        {
+            key: "findVariableByVariableIdentifier",
+            value: function findVariableByVariableIdentifier(variableIdentifier) {
+                var nested = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : true;
+                var variables = this.getVariables(nested), variable = variables.find(function(variable) {
+                    var variableComparesToVariableIdentifier = variable.compareVariableIdentifier(variableIdentifier);
+                    if (variableComparesToVariableIdentifier) {
+                        return true;
+                    }
+                }) || null;
+                return variable;
+            }
+        },
+        {
+            key: "findJudgementByMetavariable",
+            value: function findJudgementByMetavariable(metavariable) {
+                var judgements = this.getJudgements(), judgement = judgements.find(function(judgement) {
+                    var judgementSingular = judgement.isSingular();
+                    if (judgementSingular) {
+                        var judgementMetavariable = judgement.getMetavariable(), judgementMetavariableEqualToMetavariable = judgementMetavariable.isEqualTo(metavariable);
+                        if (judgementMetavariableEqualToMetavariable) {
+                            return true;
+                        }
+                    }
+                }) || null;
+                return judgement;
+            }
+        },
+        {
+            key: "findEquivalenceByTerm",
+            value: function findEquivalenceByTerm(term) {
+                return this.equivalences.findEquivalenceByTerm(term);
+            }
+        },
+        {
+            key: "isTypePresentByTypeName",
+            value: function isTypePresentByTypeName(typeName) {
+                var includeRelease = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : true, includeDependencies = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : true;
+                return this.context.isTypePresentByTypeName(typeName, includeRelease, includeDependencies);
+            }
+        },
+        {
+            key: "isVariablePresentByVariableIdentifier",
+            value: function isVariablePresentByVariableIdentifier(variableIdentifier) {
+                var nested = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : true;
+                var variable = this.findVariableByVariableIdentifier(variableIdentifier, nested), variablePresent = variable !== null;
+                return variablePresent;
+            }
+        },
+        {
+            key: "isJudgementPresentByMetavariable",
+            value: function isJudgementPresentByMetavariable(metavariable) {
+                var judgement = this.findJudgementByMetavariable(metavariable), judgementPresent = judgement !== null;
+                return judgementPresent;
+            }
+        },
+        {
+            key: "isTermGrounded",
+            value: function isTermGrounded(term) {
+                var context = this, equivalences = this.getEquivalences(), groundedTerms = [], definedVariables = [];
+                equivalences.separateGroundedTermsAndDefinedVariables(groundedTerms, definedVariables, context);
+                var termMatchesGroundedTerm = groundedTerms.some(function(groundedTerm) {
+                    var groundedTermNode = groundedTerm.getNode(), groundedTermNodeMatches = term.matchNode(groundedTermNode);
+                    if (groundedTermNodeMatches) {
+                        return true;
+                    }
+                }), termGrounded = termMatchesGroundedTerm; ///
+                return termGrounded;
+            }
+        },
+        {
+            key: "isVariableDefined",
+            value: function isVariableDefined(variable) {
+                var context = this, equivalences = this.getEquivalences(), groundedTerms = [], definedVariables = [];
+                equivalences.separateGroundedTermsAndDefinedVariables(groundedTerms, definedVariables, context);
+                var variableMatchesDefinedVariable = definedVariables.some(function(definedVariable) {
+                    var definedVariableEqualToVariable = definedVariable.isEqualTo(variable);
+                    if (definedVariableEqualToVariable === variable) {
+                        return true;
+                    }
+                }), variableDefined = variableMatchesDefinedVariable; ///
+                return variableDefined;
+            }
+        },
+        {
+            key: "isMetavariableDefined",
+            value: function isMetavariableDefined(metavariable) {
+                var judgementPresent = this.isJudgementPresentByMetavariable(metavariable), metavariableDefined = judgementPresent; ///
+                return metavariableDefined;
+            }
+        },
+        {
+            key: "compareTermAndPropertyRelation",
+            value: function compareTermAndPropertyRelation(term, propertyRelation) {
+                var context = this, proofAssertions = this.getProofAssertions(), comparesToTermAndPropertyRelation = proofAssertions.some(function(proofAssertion) {
+                    var comparesToTermAndPropertyRelation = proofAssertion.compareTermAndPropertyRelation(term, propertyRelation, context);
+                    if (comparesToTermAndPropertyRelation) {
+                        return true;
+                    }
+                });
+                return comparesToTermAndPropertyRelation;
+            }
+        }
+    ], [
+        {
+            key: "fromNothing",
+            value: function fromNothing(context) {
+                var Equivalences = _elements.default.Equivalences, variables = [], judgements = [], equivalences = Equivalences.fromNothing(), subproofOrProofAssertions = [], scopedContext = new ScopedContext(context, variables, judgements, equivalences, subproofOrProofAssertions);
+                return scopedContext;
+            }
+        }
+    ]);
+    return ScopedContext;
+}();
+var _default = ScopedContext;
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../src/context/scoped.js"],"sourcesContent":["\"use strict\";\n\nimport { arrayUtilities } from \"necessary\";\n\nimport elements from \"../elements\";\n\nimport { chainContext } from \"../utilities/context\";\n\nconst { last } = arrayUtilities;\n\nclass ScopedContext {\n  constructor(context, variables, judgements, equivalences, subproofOrProofAssertions) {\n    this.context = context;\n    this.variables = variables;\n    this.judgements = judgements;\n    this.equivalences = equivalences;\n    this.subproofOrProofAssertions = subproofOrProofAssertions;\n\n    return chainContext(this);\n  }\n\n  getContext() {\n    return this.context;\n  }\n\n  getVariables(nested = true) {\n    let variables;\n\n    if (nested) {\n      variables = this.context.getVariables();\n\n      variables = [\n        ...this.variables,\n        ...variables\n      ];\n    } else {\n      variables = this.variables;\n    }\n\n    return variables;\n  }\n\n  getJudgements() {\n    let judgements = this.context.getJudgements();\n\n    judgements = [ ///\n      ...this.judgements,\n      ...judgements\n    ]\n\n    return judgements;\n  }\n\n  getEquivalences() {\n    let equivalences = this.context.getEquivalences();\n\n    equivalences = this.equivalences.mergedWith(equivalences);  ///\n\n    return equivalences;\n  }\n\n  getProofAssertions() {\n    const subproofOrProofAssertions = this.getSubproofOrProofAssertions(),\n          proofAssertions = subproofOrProofAssertions.filter((subproofOrProofAssertion) => {\n            const subproofOrProofAssertionproofAssertion = subproofOrProofAssertion.isProofAssertion();\n\n            if (subproofOrProofAssertionproofAssertion) {\n              return true;\n            }\n          });\n\n    return proofAssertions;\n  }\n\n  getLastProofAssertion() {\n    let lastProofAssertion = null;\n\n    const proofAssertions = this.getProofAssertions(),\n          proofAssertionsLength = proofAssertions.length;\n\n    if (proofAssertionsLength > 0) {\n      lastProofAssertion = last(proofAssertions);\n    }\n\n    return lastProofAssertion;\n  }\n\n  getSubproofOrProofAssertions() {\n    let subproofOrProofAssertions = this.context.getSubproofOrProofAssertions();\n\n    subproofOrProofAssertions = [  ///\n      ...subproofOrProofAssertions,\n      ...this.subproofOrProofAssertions\n    ];\n\n    return subproofOrProofAssertions;\n  }\n\n  addEquality(equality) {\n    let equalityAdded;\n\n    const equalityReflexive = equality.isReflexive();\n\n    if (!equalityReflexive) {\n      const { Equivalence } = elements,\n            equivalence = Equivalence.fromEquality(equality),\n            context = this; ///\n\n      this.equivalences = this.equivalences.mergedWithEquivalence(equivalence, context);\n    }\n\n    equalityAdded = true;\n\n    if (equalityAdded) {\n      const context = this, ///\n            equalityString = equality.getString();\n\n      context.trace(`Added the '${equalityString}' equality.`)\n    }\n\n    return equalityAdded;\n  }\n\n  addVariable(variable, nested = true) {\n    let variableAdded = false;\n\n    const variableIdentifier = variable.getIdentifier(),\n          variablePresent = this.isVariablePresentByVariableIdentifier(variableIdentifier, nested);\n\n    if (!variablePresent) {\n      this.variables.push(variable);\n\n      variableAdded = true;\n    }\n\n    if (variableAdded) {\n      const context = this,\n            variableString = variable.getString();\n\n      context.trace(`Added the '${variableString}' variable.`)\n    }\n\n    return variableAdded;\n  }\n\n  addJudgement(judgement) {\n    let judgementAdded = false;\n\n    const metavariable = judgement.getMetavariable(),\n          judgementPresent = this.isJudgementPresentByMetavariable(metavariable);\n\n    if (!judgementPresent) {\n      this.judgements.push(judgement);\n\n      judgementAdded = true;\n    }\n\n    if (judgementAdded) {\n      const context = this, ///\n            judgementString = judgement.getString();\n\n      context.trace(`Added the '${judgementString}' judgement.`)\n    }\n\n    return judgementAdded;\n  }\n\n  addSubproofOrProofAssertion(subproofOrProofAssertion) {\n    this.subproofOrProofAssertions.push(subproofOrProofAssertion);\n  }\n\n  findVariableByVariableIdentifier(variableIdentifier, nested = true) {\n    const variables = this.getVariables(nested),\n          variable = variables.find((variable) => {\n            const variableComparesToVariableIdentifier = variable.compareVariableIdentifier(variableIdentifier);\n\n            if (variableComparesToVariableIdentifier) {\n              return true;\n            }\n          }) || null;\n\n    return variable;\n  }\n\n  findJudgementByMetavariable(metavariable) {\n    const judgements = this.getJudgements(),\n          judgement = judgements.find((judgement) => {\n            const judgementSingular = judgement.isSingular();\n\n            if (judgementSingular) {\n              const judgementMetavariable = judgement.getMetavariable(),\n                    judgementMetavariableEqualToMetavariable = judgementMetavariable.isEqualTo(metavariable);\n\n              if (judgementMetavariableEqualToMetavariable) {\n                return true;\n              }\n            }\n          }) || null;\n\n    return judgement;\n  }\n\n  findEquivalenceByTerm(term) { return this.equivalences.findEquivalenceByTerm(term); }\n\n  isTypePresentByTypeName(typeName, includeRelease = true, includeDependencies = true) { return this.context.isTypePresentByTypeName(typeName, includeRelease, includeDependencies); }\n\n  isVariablePresentByVariableIdentifier(variableIdentifier, nested = true) {\n    const variable = this.findVariableByVariableIdentifier(variableIdentifier, nested),\n          variablePresent = (variable !== null);\n\n    return variablePresent;\n  }\n\n  isJudgementPresentByMetavariable(metavariable) {\n    const judgement = this.findJudgementByMetavariable(metavariable),\n          judgementPresent = (judgement !== null);\n\n    return judgementPresent;\n  }\n\n  isTermGrounded(term) {\n    const context = this, ///\n          equivalences = this.getEquivalences(),\n          groundedTerms = [],\n          definedVariables = [];\n\n    equivalences.separateGroundedTermsAndDefinedVariables(groundedTerms, definedVariables, context);\n\n    const termMatchesGroundedTerm = groundedTerms.some((groundedTerm) => {\n        const groundedTermNode = groundedTerm.getNode(),\n              groundedTermNodeMatches = term.matchNode(groundedTermNode);\n\n            if (groundedTermNodeMatches) {\n              return true;\n            }\n          }),\n          termGrounded = termMatchesGroundedTerm; ///\n\n    return termGrounded;\n  }\n\n  isVariableDefined(variable) {\n    const context = this, ///\n          equivalences = this.getEquivalences(),\n          groundedTerms = [],\n          definedVariables = [];\n\n    equivalences.separateGroundedTermsAndDefinedVariables(groundedTerms, definedVariables, context);\n\n    const variableMatchesDefinedVariable = definedVariables.some((definedVariable) => {\n            const definedVariableEqualToVariable = definedVariable.isEqualTo(variable);\n\n            if (definedVariableEqualToVariable === variable) {\n              return true;\n            }\n          }),\n          variableDefined = variableMatchesDefinedVariable; ///\n\n    return variableDefined;\n  }\n\n  isMetavariableDefined(metavariable) {\n    const judgementPresent = this.isJudgementPresentByMetavariable(metavariable),\n          metavariableDefined = judgementPresent; ///\n\n    return metavariableDefined\n  }\n\n  compareTermAndPropertyRelation(term, propertyRelation) {\n    const context = this, ///\n          proofAssertions = this.getProofAssertions(),\n          comparesToTermAndPropertyRelation = proofAssertions.some((proofAssertion) => {\n            const comparesToTermAndPropertyRelation = proofAssertion.compareTermAndPropertyRelation(term, propertyRelation, context);\n\n            if (comparesToTermAndPropertyRelation) {\n              return true;\n            }\n          });\n\n    return comparesToTermAndPropertyRelation;\n  }\n\n  static fromNothing(context) {\n    const { Equivalences } = elements,\n          variables = [],\n          judgements = [],\n          equivalences = Equivalences.fromNothing(),\n          subproofOrProofAssertions = [],\n          scopedContext = new ScopedContext(context, variables, judgements, equivalences, subproofOrProofAssertions);\n\n    return scopedContext;\n  }\n}\n\nexport default ScopedContext;"],"names":["last","arrayUtilities","ScopedContext","context","variables","judgements","equivalences","subproofOrProofAssertions","chainContext","getContext","getVariables","nested","getJudgements","getEquivalences","mergedWith","getProofAssertions","getSubproofOrProofAssertions","proofAssertions","filter","subproofOrProofAssertion","subproofOrProofAssertionproofAssertion","isProofAssertion","getLastProofAssertion","lastProofAssertion","proofAssertionsLength","length","addEquality","equality","equalityAdded","equalityReflexive","isReflexive","Equivalence","elements","equivalence","fromEquality","mergedWithEquivalence","equalityString","getString","trace","addVariable","variable","variableAdded","variableIdentifier","getIdentifier","variablePresent","isVariablePresentByVariableIdentifier","push","variableString","addJudgement","judgement","judgementAdded","metavariable","getMetavariable","judgementPresent","isJudgementPresentByMetavariable","judgementString","addSubproofOrProofAssertion","findVariableByVariableIdentifier","find","variableComparesToVariableIdentifier","compareVariableIdentifier","findJudgementByMetavariable","judgementSingular","isSingular","judgementMetavariable","judgementMetavariableEqualToMetavariable","isEqualTo","findEquivalenceByTerm","term","isTypePresentByTypeName","typeName","includeRelease","includeDependencies","isTermGrounded","groundedTerms","definedVariables","separateGroundedTermsAndDefinedVariables","termMatchesGroundedTerm","some","groundedTerm","groundedTermNode","getNode","groundedTermNodeMatches","matchNode","termGrounded","isVariableDefined","variableMatchesDefinedVariable","definedVariable","definedVariableEqualToVariable","variableDefined","isMetavariableDefined","metavariableDefined","compareTermAndPropertyRelation","propertyRelation","comparesToTermAndPropertyRelation","proofAssertion","fromNothing","Equivalences","scopedContext"],"mappings":"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"}