occam-verify-cli 0.0.913 → 0.0.915

package/lib/context/local/intrinsicLevel.js

@@ -0,0 +1,326 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return _default;
+    }
+});
+var _variable = /*#__PURE__*/ _interop_require_default(require("../../variable"));
+var _equivalence = /*#__PURE__*/ _interop_require_default(require("../../equivalence"));
+var _context = /*#__PURE__*/ _interop_require_default(require("../../mixins/context"));
+var _array = require("../../utilities/array");
+var _equivalences = require("../../utilities/equivalences");
+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 IntrinsicLevelLocalContext = /*#__PURE__*/ function() {
+    function IntrinsicLevelLocalContext(context, variables, proofSteps, equivalences) {
+        _class_call_check(this, IntrinsicLevelLocalContext);
+        this.context = context;
+        this.variables = variables;
+        this.proofSteps = proofSteps;
+        this.equivalences = equivalences;
+    }
+    _create_class(IntrinsicLevelLocalContext, [
+        {
+            key: "getContext",
+            value: function getContext() {
+                return this.context;
+            }
+        },
+        {
+            key: "getVariables",
+            value: function getVariables() {
+                var variables = this.context.getVariables();
+                variables = _to_consumable_array(this.variables).concat(_to_consumable_array(variables));
+                return variables;
+            }
+        },
+        {
+            key: "getProofSteps",
+            value: function getProofSteps() {
+                var proofSteps = this.context.getProofSteps();
+                proofSteps = _to_consumable_array(proofSteps).concat(_to_consumable_array(this.proofSteps));
+                return proofSteps;
+            }
+        },
+        {
+            key: "getEquivalences",
+            value: function getEquivalences() {
+                var equivalences = this.context.getEquivalences();
+                var equivalencesA = this.equivalences, equivalencesB = equivalences, intrinsicLevelLocalContext = this; ///
+                equivalences = (0, _equivalences.mergeEquivalences)(equivalencesA, equivalencesB, intrinsicLevelLocalContext); ///
+                return equivalences;
+            }
+        },
+        {
+            key: "isIntrinsicLevel",
+            value: function isIntrinsicLevel() {
+                var intrinsicLevel = true;
+                return intrinsicLevel;
+            }
+        },
+        {
+            key: "getLastProofStep",
+            value: function getLastProofStep() {
+                var lastProofStep = null;
+                var proofStepsLength = this.proofSteps.length;
+                if (proofStepsLength > 0) {
+                    lastProofStep = (0, _array.last)(this.proofSteps);
+                }
+                return lastProofStep;
+            }
+        },
+        {
+            key: "getTermType",
+            value: function getTermType(term) {
+                var termType;
+                var equivalences = this.getEquivalences(), equivalence = (0, _equivalences.findEquivalenceByTerm)(equivalences, term);
+                if (equivalence !== null) {
+                    var intrinsicLevelLocalContext = this, equivalenceType = equivalence.getType(intrinsicLevelLocalContext);
+                    termType = equivalenceType; ///
+                } else {
+                    termType = term.getType();
+                }
+                return termType;
+            }
+        },
+        {
+            key: "isTermGrounded",
+            value: function isTermGrounded(term) {
+                var context = this, equivalences = this.getEquivalences(), groundedTerms = [], definedVariables = [];
+                (0, _equivalences.groundedTermsAndDefinedVariablesFromFromEquivalences)(equivalences, groundedTerms, definedVariables, context);
+                var termMatchesGroundedTerm = groundedTerms.some(function(groundedTerm) {
+                    var termMatchesGroundedTerm = term.match(groundedTerm);
+                    if (termMatchesGroundedTerm) {
+                        return true;
+                    }
+                }), termGrounded = termMatchesGroundedTerm; ///
+                return termGrounded;
+            }
+        },
+        {
+            key: "isVariableDefined",
+            value: function isVariableDefined(variable) {
+                var context = this, equivalences = this.getEquivalences(), groundedTerms = [], definedVariables = [];
+                (0, _equivalences.groundedTermsAndDefinedVariablesFromFromEquivalences)(equivalences, groundedTerms, definedVariables, context);
+                var variableMatchesDefinedVariable = definedVariables.some(function(definedVariable) {
+                    var variableMatchesDefinedVariable = variable.match(definedVariable);
+                    if (variableMatchesDefinedVariable) {
+                        return true;
+                    }
+                }), variableDefined = variableMatchesDefinedVariable; ///
+                return variableDefined;
+            }
+        },
+        {
+            key: "addEquality",
+            value: function addEquality(equality) {
+                var equalityAdded;
+                var equalityReflexive = equality.isReflexive();
+                if (equalityReflexive) {
+                    equalityAdded = true; ///
+                } else {
+                    var leftTerm = equality.getLeftTerm(), rightTerm = equality.getRightTerm(), leftEquivalence = (0, _equivalences.findEquivalenceByTerm)(this.equivalences, leftTerm), rightEquivalence = (0, _equivalences.findEquivalenceByTerm)(this.equivalences, rightTerm);
+                    if (false) {
+                    ///
+                    } else if (leftEquivalence === null && rightEquivalence === null) {
+                        var equivalence = _equivalence.default.fromLeftTermAndRightTerm(leftTerm, rightTerm);
+                        this.addEquivalence(equivalence);
+                        equalityAdded = true;
+                    } else if (leftEquivalence !== null && rightEquivalence === null) {
+                        leftEquivalence.addTerm(rightTerm);
+                        equalityAdded = true;
+                    } else if (leftEquivalence === null && rightEquivalence !== null) {
+                        rightEquivalence.addTerm(leftTerm);
+                        equalityAdded = true;
+                    } else if (leftEquivalence !== null && rightEquivalence !== null) {
+                        var equivalence1;
+                        if (leftEquivalence === rightEquivalence) {
+                            equivalence1 = leftEquivalence; ///
+                        } else {
+                            equivalence1 = _equivalence.default.merge(leftEquivalence, rightEquivalence);
+                            this.removeEquivalence(leftEquivalence);
+                            this.removeEquivalence(rightEquivalence);
+                            this.addEquivalence(equivalence1);
+                        }
+                        equivalence1.addTerm(leftTerm);
+                        equivalence1.addTerm(rightTerm);
+                        equalityAdded = true;
+                    }
+                }
+                return equalityAdded;
+            }
+        },
+        {
+            key: "addVariable",
+            value: function addVariable(variable) {
+                var variableAdded = false;
+                var node = variable.getNode(), variablePresent = this.variables.some(function(variable) {
+                    var variableMatchesNode = variable.matchNode(node);
+                    if (variableMatchesNode) {
+                        return true;
+                    }
+                });
+                if (!variablePresent) {
+                    this.variables.push(variable);
+                    variableAdded = true;
+                }
+                return variableAdded;
+            }
+        },
+        {
+            key: "addProofStep",
+            value: function addProofStep(proofStep) {
+                this.proofSteps.push(proofStep);
+            }
+        },
+        {
+            key: "addEquivalence",
+            value: function addEquivalence(equivalence) {
+                this.equivalences.push(equivalence);
+            }
+        },
+        {
+            key: "removeEquivalence",
+            value: function removeEquivalence(equivalence) {
+                var index = this.equivalences.indexOf(equivalence), start = index, deleteCount = 1;
+                this.equivalences.splice(start, deleteCount);
+            }
+        },
+        {
+            key: "matchStatementNode",
+            value: function matchStatementNode(statementNode) {
+                var proofSteps = this.getProofSteps();
+                proofSteps = (0, _array.reverse)(proofSteps); ///
+                var matchesStatementNode = proofSteps.some(function(proofStep) {
+                    var proofStepMatchesStatementNode = proofStep.matchStatementNode(statementNode);
+                    if (proofStepMatchesStatementNode) {
+                        return true;
+                    }
+                });
+                return matchesStatementNode;
+            }
+        },
+        {
+            key: "findVariableByVariableNode",
+            value: function findVariableByVariableNode(variableNode) {
+                var node = variableNode, variables = this.getVariables(), variable = variables.find(function(variable) {
+                    var matches = variable.matchNode(node);
+                    if (matches) {
+                        return true;
+                    }
+                }) || null;
+                return variable;
+            }
+        },
+        {
+            key: "findMetaTypeByMetaTypeNode",
+            value: function findMetaTypeByMetaTypeNode(metaTypeNode) {
+                return this.context.findMetaTypeByMetaTypeNode(metaTypeNode);
+            }
+        },
+        {
+            key: "isVariablePresentByVariableNode",
+            value: function isVariablePresentByVariableNode(variableNode) {
+                var variable = this.findVariableByVariableNode(variableNode), variablePresent = variable !== null;
+                return variablePresent;
+            }
+        },
+        {
+            key: "toJSON",
+            value: function toJSON(tokens) {
+                var variables = this.variables.map(function(variable) {
+                    var variableJSON = variable.toJSON(tokens);
+                    variable = variableJSON;
+                    return variable;
+                }), json = {
+                    variables: variables
+                };
+                return json;
+            }
+        }
+    ], [
+        {
+            key: "fromFileContext",
+            value: function fromFileContext(fileContext) {
+                var context = fileContext, variables = [], proofSteps = [], equivalences = [], intrinsicLevelLocalContext = new IntrinsicLevelLocalContext(context, variables, proofSteps, equivalences);
+                return intrinsicLevelLocalContext;
+            }
+        },
+        {
+            key: "fromLocalContext",
+            value: function fromLocalContext(localContext) {
+                var context = localContext, variables = [], proofSteps = [], equivalences = [], intrinsicLevelLocalContext = new IntrinsicLevelLocalContext(context, variables, proofSteps, equivalences);
+                return intrinsicLevelLocalContext;
+            }
+        },
+        {
+            key: "fromJSONAndFileContext",
+            value: function fromJSONAndFileContext(json, fileContext) {
+                var variables = json.variables;
+                var variablesJSON = variables;
+                variables = variablesJSON.map(function(variableJSON) {
+                    var _$json = variableJSON, variable = _variable.default.fromJSONAndFileContext(_$json, fileContext);
+                    return variable;
+                });
+                var context = fileContext, proofSteps = [], equivalences = [], intrinsicLevelLocalContext = new IntrinsicLevelLocalContext(context, variables, proofSteps, equivalences);
+                return intrinsicLevelLocalContext;
+            }
+        }
+    ]);
+    return IntrinsicLevelLocalContext;
+}();
+Object.assign(IntrinsicLevelLocalContext.prototype, _context.default);
+var _default = IntrinsicLevelLocalContext;
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../src/context/local/intrinsicLevel.js"],"sourcesContent":["\"use strict\";\n\nimport Variable from \"../../variable\";\nimport Equivalence from \"../../equivalence\";\nimport contextMixins from \"../../mixins/context\";\n\nimport { last, reverse } from \"../../utilities/array\";\nimport { mergeEquivalences, findEquivalenceByTerm, groundedTermsAndDefinedVariablesFromFromEquivalences } from \"../../utilities/equivalences\";\n\nclass IntrinsicLevelLocalContext {\n  constructor(context, variables, proofSteps, equivalences) {\n    this.context = context;\n    this.variables = variables;\n    this.proofSteps = proofSteps;\n    this.equivalences = equivalences;\n  }\n\n  getContext() {\n    return this.context;\n  }\n\n  getVariables() {\n    let variables = this.context.getVariables();\n\n    variables = [ ///\n      ...this.variables,\n      ...variables\n    ];\n\n    return variables;\n  }\n\n  getProofSteps() {\n    let proofSteps = this.context.getProofSteps();\n\n    proofSteps = [  ///\n      ...proofSteps,\n      ...this.proofSteps\n    ];\n\n    return proofSteps;\n  }\n\n  getEquivalences() {\n    let equivalences = this.context.getEquivalences();\n\n    const equivalencesA = this.equivalences, ///\n          equivalencesB = equivalences,\n          intrinsicLevelLocalContext = this;  ///\n\n    equivalences = mergeEquivalences(equivalencesA, equivalencesB, intrinsicLevelLocalContext); ///\n\n    return equivalences;\n  }\n\n  isIntrinsicLevel() {\n    const intrinsicLevel = true;\n\n    return intrinsicLevel;\n  }\n\n  getLastProofStep() {\n    let lastProofStep = null;\n\n    const proofStepsLength = this.proofSteps.length;\n\n    if (proofStepsLength > 0) {\n      lastProofStep = last(this.proofSteps);\n    }\n\n    return lastProofStep;\n  }\n\n  getTermType(term) {\n    let termType;\n\n    const equivalences = this.getEquivalences(),\n          equivalence = findEquivalenceByTerm(equivalences, term);\n\n    if (equivalence !== null) {\n      const intrinsicLevelLocalContext = this,  ///\n            equivalenceType = equivalence.getType(intrinsicLevelLocalContext);\n\n      termType = equivalenceType;  ///\n    } else {\n      termType = term.getType();\n    }\n\n    return termType;\n  }\n\n  isTermGrounded(term) {\n    const context = this,\n          equivalences = this.getEquivalences(),\n          groundedTerms = [],\n          definedVariables = [];\n\n    groundedTermsAndDefinedVariablesFromFromEquivalences(equivalences, groundedTerms, definedVariables, context);\n\n    const termMatchesGroundedTerm = groundedTerms.some((groundedTerm) => {\n            const termMatchesGroundedTerm = term.match(groundedTerm);\n\n            if (termMatchesGroundedTerm) {\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    groundedTermsAndDefinedVariablesFromFromEquivalences(equivalences, groundedTerms, definedVariables, context);\n\n    const variableMatchesDefinedVariable = definedVariables.some((definedVariable) => {\n            const variableMatchesDefinedVariable = variable.match(definedVariable);\n\n            if (variableMatchesDefinedVariable) {\n              return true;\n            }\n          }),\n          variableDefined = variableMatchesDefinedVariable; ///\n\n    return variableDefined;\n  }\n\n  addEquality(equality) {\n    let equalityAdded;\n\n    const equalityReflexive = equality.isReflexive();\n\n    if (equalityReflexive) {\n      equalityAdded = true; ///\n    } else {\n      const leftTerm = equality.getLeftTerm(),\n            rightTerm = equality.getRightTerm(),\n            leftEquivalence = findEquivalenceByTerm(this.equivalences, leftTerm),\n            rightEquivalence = findEquivalenceByTerm(this.equivalences, rightTerm);\n\n      if (false) {\n        ///\n      } else if ((leftEquivalence === null) && (rightEquivalence === null)) {\n        const equivalence = Equivalence.fromLeftTermAndRightTerm(leftTerm, rightTerm);\n\n        this.addEquivalence(equivalence);\n\n        equalityAdded = true;\n      } else if ((leftEquivalence !== null) && (rightEquivalence === null)) {\n        leftEquivalence.addTerm(rightTerm);\n\n        equalityAdded = true;\n      } else if ((leftEquivalence === null) && (rightEquivalence !== null)) {\n        rightEquivalence.addTerm(leftTerm);\n\n        equalityAdded = true;\n      } else if ((leftEquivalence !== null) && (rightEquivalence !== null)) {\n        let equivalence;\n\n        if (leftEquivalence === rightEquivalence) {\n          equivalence = leftEquivalence;  ///\n        } else {\n          equivalence = Equivalence.merge(leftEquivalence, rightEquivalence);\n\n          this.removeEquivalence(leftEquivalence);\n\n          this.removeEquivalence(rightEquivalence);\n\n          this.addEquivalence(equivalence);\n        }\n\n        equivalence.addTerm(leftTerm);\n\n        equivalence.addTerm(rightTerm);\n\n        equalityAdded = true;\n      }\n    }\n\n    return equalityAdded;\n  }\n\n  addVariable(variable) {\n    let variableAdded = false;\n\n    const node = variable.getNode(),\n          variablePresent = this.variables.some((variable) => {\n            const variableMatchesNode = variable.matchNode(node);\n\n            if (variableMatchesNode) {\n              return true;\n            }\n          });\n\n    if (!variablePresent) {\n      this.variables.push(variable);\n\n      variableAdded = true;\n    }\n\n    return variableAdded;\n  }\n\n  addProofStep(proofStep) {\n    this.proofSteps.push(proofStep);\n  }\n\n  addEquivalence(equivalence) {\n    this.equivalences.push(equivalence);\n  }\n\n  removeEquivalence(equivalence) {\n    const index = this.equivalences.indexOf(equivalence),\n          start = index,  ///\n          deleteCount = 1;\n\n    this.equivalences.splice(start, deleteCount);\n  }\n\n  matchStatementNode(statementNode) {\n    let proofSteps = this.getProofSteps();\n\n    proofSteps = reverse(proofSteps); ///\n\n    const matchesStatementNode = proofSteps.some((proofStep) => {\n      const proofStepMatchesStatementNode = proofStep.matchStatementNode(statementNode);\n\n      if (proofStepMatchesStatementNode) {\n        return true;\n      }\n    });\n\n    return matchesStatementNode;\n  }\n\n  findVariableByVariableNode(variableNode) {\n    const node = variableNode,  ///\n          variables = this.getVariables(),\n          variable = variables.find((variable) => {\n            const matches = variable.matchNode(node);\n\n            if (matches) {\n              return true;\n            }\n          }) || null;\n\n    return variable;\n  }\n\n  findMetaTypeByMetaTypeNode(metaTypeNode) { return this.context.findMetaTypeByMetaTypeNode(metaTypeNode); }\n\n  isVariablePresentByVariableNode(variableNode) {\n    const variable = this.findVariableByVariableNode(variableNode),\n          variablePresent = (variable !== null);\n\n    return variablePresent;\n  }\n\n  toJSON(tokens) {\n    const variables = this.variables.map((variable) => {\n            const variableJSON = variable.toJSON(tokens);\n\n            variable = variableJSON;\n\n            return variable;\n          }),\n          json = {\n            variables\n          };\n\n    return json;\n  }\n\n  static fromFileContext(fileContext) {\n    const context = fileContext,  ///\n          variables = [],\n          proofSteps = [],\n          equivalences = [],\n          intrinsicLevelLocalContext = new IntrinsicLevelLocalContext(context, variables, proofSteps, equivalences);\n\n    return intrinsicLevelLocalContext;\n  }\n\n  static fromLocalContext(localContext) {\n    const context = localContext,  ///\n          variables = [],\n          proofSteps = [],\n          equivalences = [],\n          intrinsicLevelLocalContext = new IntrinsicLevelLocalContext(context, variables, proofSteps, equivalences);\n\n    return intrinsicLevelLocalContext;\n  }\n\n  static fromJSONAndFileContext(json, fileContext) {\n    let { variables } = json;\n\n    const variablesJSON = variables;\n\n    variables = variablesJSON.map((variableJSON) => {\n      const json = variableJSON,  ///\n            variable = Variable.fromJSONAndFileContext(json, fileContext);\n\n      return variable;\n    });\n\n    const context = fileContext,  ///\n          proofSteps = [],\n          equivalences = [],\n          intrinsicLevelLocalContext = new IntrinsicLevelLocalContext(context, variables, proofSteps, equivalences);\n\n    return intrinsicLevelLocalContext;\n  }\n}\n\nObject.assign(IntrinsicLevelLocalContext.prototype, contextMixins);\n\nexport default IntrinsicLevelLocalContext;\n"],"names":["IntrinsicLevelLocalContext","context","variables","proofSteps","equivalences","getContext","getVariables","getProofSteps","getEquivalences","equivalencesA","equivalencesB","intrinsicLevelLocalContext","mergeEquivalences","isIntrinsicLevel","intrinsicLevel","getLastProofStep","lastProofStep","proofStepsLength","length","last","getTermType","term","termType","equivalence","findEquivalenceByTerm","equivalenceType","getType","isTermGrounded","groundedTerms","definedVariables","groundedTermsAndDefinedVariablesFromFromEquivalences","termMatchesGroundedTerm","some","groundedTerm","match","termGrounded","isVariableDefined","variable","variableMatchesDefinedVariable","definedVariable","variableDefined","addEquality","equality","equalityAdded","equalityReflexive","isReflexive","leftTerm","getLeftTerm","rightTerm","getRightTerm","leftEquivalence","rightEquivalence","Equivalence","fromLeftTermAndRightTerm","addEquivalence","addTerm","merge","removeEquivalence","addVariable","variableAdded","node","getNode","variablePresent","variableMatchesNode","matchNode","push","addProofStep","proofStep","index","indexOf","start","deleteCount","splice","matchStatementNode","statementNode","reverse","matchesStatementNode","proofStepMatchesStatementNode","findVariableByVariableNode","variableNode","find","matches","findMetaTypeByMetaTypeNode","metaTypeNode","isVariablePresentByVariableNode","toJSON","tokens","map","variableJSON","json","fromFileContext","fileContext","fromLocalContext","localContext","fromJSONAndFileContext","variablesJSON","Variable","Object","assign","prototype","contextMixins"],"mappings":"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"}