occam-verify-cli 0.0.921 → 0.0.923

package/lib/context/local.js

@@ -0,0 +1,386 @@
+"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 LocalContext = /*#__PURE__*/ function() {
+    function LocalContext(context, variables, proofSteps, judgements, equivalences, metavariables) {
+        _class_call_check(this, LocalContext);
+        this.context = context;
+        this.variables = variables;
+        this.proofSteps = proofSteps;
+        this.judgements = judgements;
+        this.equivalences = equivalences;
+        this.metavariables = metavariables;
+    }
+    _create_class(LocalContext, [
+        {
+            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: "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();
+                var equivalencesA = this.equivalences, equivalencesB = equivalences, _$LocalContext = this; ///
+                equivalences = (0, _equivalences.mergeEquivalences)(equivalencesA, equivalencesB, _$LocalContext); ///
+                return equivalences;
+            }
+        },
+        {
+            key: "getMetavariables",
+            value: function getMetavariables() {
+                var metavariables = this.context.getMetavariables();
+                metavariables = _to_consumable_array(this.metavariables).concat(_to_consumable_array(metavariables));
+                return metavariables;
+            }
+        },
+        {
+            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: "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: "addJudgement",
+            value: function addJudgement(judgement) {
+                var judgementAdded = false;
+                var metavariableNode = judgement.getMetavariableNode(), judgementPresent = this.isJudgementPresentByMetavariableNode(metavariableNode);
+                if (!judgementPresent) {
+                    this.judgements.push(judgement);
+                    judgementAdded = true;
+                }
+                return judgementAdded;
+            }
+        },
+        {
+            key: "addMetavariable",
+            value: function addMetavariable(metavariable) {
+                var metavariableAdded = false;
+                var node = metavariable.getName(), metavariablePresent = this.metavariables.some(function(metavariable) {
+                    var metavariableMatchesNode = metavariable.matchNode(node);
+                    if (metavariableMatchesNode) {
+                        return true;
+                    }
+                });
+                if (!metavariablePresent) {
+                    this.metavariables.push(metavariable);
+                    metavariableAdded = true;
+                }
+                return metavariableAdded;
+            }
+        },
+        {
+            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: "getTermType",
+            value: function getTermType(term) {
+                var termType;
+                var equivalences = this.getEquivalences(), equivalence = (0, _equivalences.findEquivalenceByTerm)(equivalences, term);
+                if (equivalence !== null) {
+                    var _$LocalContext = this, equivalenceType = equivalence.getType(_$LocalContext);
+                    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: "isVariablePresentByVariableNode",
+            value: function isVariablePresentByVariableNode(variableNode) {
+                var variable = this.findVariableByVariableNode(variableNode), variablePresent = variable !== null;
+                return variablePresent;
+            }
+        },
+        {
+            key: "isJudgementPresentByMetavariableNode",
+            value: function isJudgementPresentByMetavariableNode(metavariableNode) {
+                var judgement = this.findJudgementByMetavariableNode(metavariableNode), judgementPresent = judgement !== null;
+                return judgementPresent;
+            }
+        },
+        {
+            key: "isMetavariablePresentByMetavariableNode",
+            value: function isMetavariablePresentByMetavariableNode(metavariableNode, localContext) {
+                var metavariable = this.findMetavariableByMetavariableNode(metavariableNode, localContext), metavariablePresent = metavariable !== null;
+                return metavariablePresent;
+            }
+        },
+        {
+            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: "findJudgementByMetavariableNode",
+            value: function findJudgementByMetavariableNode(metavariableNode) {
+                var judgements = this.getJudgements(), judgement = judgements.find(function(judgement) {
+                    var judgementMatchesMetavariableNode = judgement.matchMetavariableNode(metavariableNode);
+                    if (judgementMatchesMetavariableNode) {
+                        return true;
+                    }
+                }) || null;
+                return judgement;
+            }
+        },
+        {
+            key: "findMetavariableByMetavariableNode",
+            value: function findMetavariableByMetavariableNode(metavariableNode, localContext) {
+                var node = metavariableNode, metavariables = this.getMetavariables(), metavariable = metavariables.find(function(metavariable) {
+                    var matches = metavariable.matchNode(node, localContext);
+                    if (matches) {
+                        return true;
+                    }
+                }) || null;
+                return metavariable;
+            }
+        }
+    ], [
+        {
+            key: "fromFileContext",
+            value: function fromFileContext(fileContext) {
+                var context = fileContext, variables = [], proofSteps = [], equivalences = [], judgements = [], metavariables = [], localContext = new LocalContext(context, variables, proofSteps, judgements, equivalences, metavariables);
+                return localContext;
+            }
+        },
+        {
+            key: "fromLocalContext",
+            value: function fromLocalContext(localContext) {
+                var context = localContext, variables = [], proofSteps = [], equivalences = [], judgements = [], metavariables = [];
+                localContext = new LocalContext(context, variables, proofSteps, judgements, equivalences, metavariables); ///
+                return localContext;
+            }
+        },
+        {
+            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 = [], judgements = [], metavariables = [], localContext = new LocalContext(context, variables, proofSteps, judgements, equivalences, metavariables); ///
+                return localContext;
+            }
+        }
+    ]);
+    return LocalContext;
+}();
+Object.assign(LocalContext.prototype, _context.default);
+var _default = LocalContext;
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../src/context/local.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 LocalContext {\n  constructor(context, variables, proofSteps, judgements, equivalences, metavariables) {\n    this.context = context;\n    this.variables = variables;\n    this.proofSteps = proofSteps;\n    this.judgements = judgements;\n    this.equivalences = equivalences;\n    this.metavariables = metavariables;\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  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    const equivalencesA = this.equivalences, ///\n          equivalencesB = equivalences,\n          LocalContext = this;  ///\n\n    equivalences = mergeEquivalences(equivalencesA, equivalencesB, LocalContext); ///\n\n    return equivalences;\n  }\n\n  getMetavariables() {\n    let metavariables = this.context.getMetavariables();\n\n    metavariables = [ ///\n      ...this.metavariables,\n      ...metavariables\n    ]\n\n    return metavariables;\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  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  addJudgement(judgement) {\n    let judgementAdded = false;\n\n    const metavariableNode = judgement.getMetavariableNode(),\n          judgementPresent = this.isJudgementPresentByMetavariableNode(metavariableNode);\n\n    if (!judgementPresent) {\n      this.judgements.push(judgement);\n\n      judgementAdded = true;\n    }\n\n    return judgementAdded;\n  }\n\n  addMetavariable(metavariable) {\n    let metavariableAdded = false;\n\n    const node = metavariable.getName(),\n          metavariablePresent = this.metavariables.some((metavariable) => {\n            const metavariableMatchesNode = metavariable.matchNode(node);\n\n            if (metavariableMatchesNode) {\n              return true;\n            }\n          });\n\n    if (!metavariablePresent) {\n      this.metavariables.push(metavariable);\n\n      metavariableAdded = true;\n    }\n\n    return metavariableAdded;\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  getTermType(term) {\n    let termType;\n\n    const equivalences = this.getEquivalences(),\n          equivalence = findEquivalenceByTerm(equivalences, term);\n\n    if (equivalence !== null) {\n      const LocalContext = this,  ///\n            equivalenceType = equivalence.getType(LocalContext);\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  isVariablePresentByVariableNode(variableNode) {\n    const variable = this.findVariableByVariableNode(variableNode),\n          variablePresent = (variable !== null);\n\n    return variablePresent;\n  }\n\n  isJudgementPresentByMetavariableNode(metavariableNode) {\n    const judgement = this.findJudgementByMetavariableNode(metavariableNode),\n          judgementPresent = (judgement !== null);\n\n    return judgementPresent;\n  }\n\n  isMetavariablePresentByMetavariableNode(metavariableNode, localContext) {\n    const metavariable = this.findMetavariableByMetavariableNode(metavariableNode, localContext),\n          metavariablePresent = (metavariable !== null);\n\n    return metavariablePresent;\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  findJudgementByMetavariableNode(metavariableNode) {\n    const judgements = this.getJudgements(),\n          judgement = judgements.find((judgement) => {\n            const judgementMatchesMetavariableNode = judgement.matchMetavariableNode(metavariableNode);\n\n            if (judgementMatchesMetavariableNode) {\n              return true;\n            }\n          }) || null;\n\n    return judgement;\n  }\n\n  findMetavariableByMetavariableNode(metavariableNode, localContext) {\n    const node = metavariableNode,  ///\n          metavariables = this.getMetavariables(),\n          metavariable = metavariables.find((metavariable) => {\n            const matches = metavariable.matchNode(node, localContext);\n\n            if (matches) {\n              return true;\n            }\n          }) || null;\n\n    return metavariable;\n  }\n\n  static fromFileContext(fileContext) {\n    const context = fileContext,  ///\n          variables = [],\n          proofSteps = [],\n          equivalences = [],\n          judgements = [],\n          metavariables = [],\n          localContext = new LocalContext(context, variables, proofSteps, judgements, equivalences, metavariables);\n\n    return localContext;\n  }\n\n  static fromLocalContext(localContext) {\n    const context = localContext,  ///\n          variables = [],\n          proofSteps = [],\n          equivalences = [],\n          judgements = [],\n          metavariables = [];\n\n    localContext = new LocalContext(context, variables, proofSteps, judgements, equivalences, metavariables);  ///\n\n    return localContext;\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          judgements = [],\n          metavariables = [],\n          localContext = new LocalContext(context, variables, proofSteps, judgements, equivalences, metavariables);  ///\n\n    return localContext;\n  }\n}\n\nObject.assign(LocalContext.prototype, contextMixins);\n\nexport default LocalContext;"],"names":["LocalContext","context","variables","proofSteps","judgements","equivalences","metavariables","getContext","getVariables","getProofSteps","getJudgements","getEquivalences","equivalencesA","equivalencesB","mergeEquivalences","getMetavariables","getLastProofStep","lastProofStep","proofStepsLength","length","last","addEquality","equality","equalityAdded","equalityReflexive","isReflexive","leftTerm","getLeftTerm","rightTerm","getRightTerm","leftEquivalence","findEquivalenceByTerm","rightEquivalence","equivalence","Equivalence","fromLeftTermAndRightTerm","addEquivalence","addTerm","merge","removeEquivalence","addVariable","variable","variableAdded","node","getNode","variablePresent","some","variableMatchesNode","matchNode","push","addProofStep","proofStep","index","indexOf","start","deleteCount","splice","addJudgement","judgement","judgementAdded","metavariableNode","getMetavariableNode","judgementPresent","isJudgementPresentByMetavariableNode","addMetavariable","metavariable","metavariableAdded","getName","metavariablePresent","metavariableMatchesNode","matchStatementNode","statementNode","reverse","matchesStatementNode","proofStepMatchesStatementNode","getTermType","term","termType","equivalenceType","getType","isTermGrounded","groundedTerms","definedVariables","groundedTermsAndDefinedVariablesFromFromEquivalences","termMatchesGroundedTerm","groundedTerm","match","termGrounded","isVariableDefined","variableMatchesDefinedVariable","definedVariable","variableDefined","isVariablePresentByVariableNode","variableNode","findVariableByVariableNode","findJudgementByMetavariableNode","isMetavariablePresentByMetavariableNode","localContext","findMetavariableByMetavariableNode","find","matches","judgementMatchesMetavariableNode","matchMetavariableNode","fromFileContext","fileContext","fromLocalContext","fromJSONAndFileContext","json","variablesJSON","map","variableJSON","Variable","Object","assign","prototype","contextMixins"],"mappings":"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"}

package/lib/declaration.js

@@ -29,10 +29,10 @@ function _create_class(Constructor, protoProps, staticProps) {
     return Constructor;
 }
 var Declaration = /*#__PURE__*/ function() {
-    function Declaration(metavariableNode, metastatementNode) {
+    function Declaration(metavariableNode, statementNode) {
         _class_call_check(this, Declaration);
         this.metavariableNode = metavariableNode;
-        this.metastatementNode = metastatementNode;
+        this.statementNode = statementNode;
     }
     _create_class(Declaration, [
         {
@@ -42,15 +42,15 @@ var Declaration = /*#__PURE__*/ function() {
             }
         },
         {
-            key: "getMetastatementNode",
-            value: function getMetastatementNode() {
-                return this.metastatementNode;
+            key: "getStatementNode",
+            value: function getStatementNode() {
+                return this.statementNode;
             }
         },
         {
             key: "matchSubstitution",
             value: function matchSubstitution(substitution) {
-                var metavariableNode = substitution.getMetavariableNode(), metastatementNode = substitution.getMetastatementNode(), matchesMetavariableNode = this.matchMetavariableNode(metavariableNode), matchesMetastatementNode = this.matchMetastatementNode(metastatementNode), matchesSubstitution = matchesMetavariableNode && matchesMetastatementNode;
+                var statementNode = substitution.getStatementNode(), metavariableNode = substitution.getMetavariableNode(), matchesStatementNode = this.matchStatementNode(statementNode), matchesMetavariableNode = this.matchMetavariableNode(metavariableNode), matchesSubstitution = matchesMetavariableNode && matchesStatementNode;
                 return matchesSubstitution;
             }
         },
@@ -62,24 +62,24 @@ var Declaration = /*#__PURE__*/ function() {
             }
         },
         {
-            key: "matchMetastatementNode",
-            value: function matchMetastatementNode(metastatementNode) {
-                var metastatementNodeA = metastatementNode, metastatementNodeB = this.metastatementNode, metastatementMatches = (0, _match.matchMetastatementModuloBrackets)(metastatementNodeA, metastatementNodeB), matchesMetastatementNode = metastatementMatches; ///
-                return matchesMetastatementNode;
+            key: "matchStatementNode",
+            value: function matchStatementNode(statementNode) {
+                var statementNodeA = statementNode, statementNodeB = this.statementNode, statementMatches = (0, _match.matchStatementModuloBrackets)(statementNodeA, statementNodeB), matchesStatementNode = statementMatches; ///
+                return matchesStatementNode;
             }
         },
         {
             key: "matchMetaLemmaOrMetaTheorem",
             value: function matchMetaLemmaOrMetaTheorem(metaLemmaMetatheorem) {
-                var metaConsequent = metaLemmaMetatheorem.getMetaConsequent(), metastatementNode = metaConsequent.getMetastatementNode(), matches = this.metastatementNode.match(metastatementNode), matchesMetaLemmaOrMetaTheorem = matches; ///
+                var metaConsequent = metaLemmaMetatheorem.getMetaConsequent(), statementNode = metaConsequent.getStatementNode(), matches = this.statementNode.match(statementNode), matchesMetaLemmaOrMetaTheorem = matches; ///
                 return matchesMetaLemmaOrMetaTheorem;
             }
         }
     ], [
         {
-            key: "fromMetavariableNodeAndMetastatementNode",
-            value: function fromMetavariableNodeAndMetastatementNode(metavariableNode, metastatementNode) {
-                var declaration = new Declaration(metavariableNode, metastatementNode);
+            key: "fromMetavariableNodeAndStatementNode",
+            value: function fromMetavariableNodeAndStatementNode(metavariableNode, statementNode) {
+                var declaration = new Declaration(metavariableNode, statementNode);
                 return declaration;
             }
         }
@@ -87,4 +87,4 @@ var Declaration = /*#__PURE__*/ function() {
     return Declaration;
 }();
 
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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