occam-verify-cli 1.0.421 → 1.0.427

package/lib/element/axiomLemmaTheoremConjecture.js

@@ -0,0 +1,346 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return AxiomLemmaTheoremConjecture;
+    }
+});
+var _necessary = require("necessary");
+var _elements = /*#__PURE__*/ _interop_require_default(require("../elements"));
+var _local = /*#__PURE__*/ _interop_require_default(require("../context/local"));
+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 _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+var extract = _necessary.arrayUtilities.extract, reverse = _necessary.arrayUtilities.reverse, correlate = _necessary.arrayUtilities.correlate, backwardsEvery = _necessary.arrayUtilities.backwardsEvery;
+var AxiomLemmaTheoremConjecture = /*#__PURE__*/ function() {
+    function AxiomLemmaTheoremConjecture(context, string, node, labels, suppositions, deduction, proof, signature, hypotheses) {
+        _class_call_check(this, AxiomLemmaTheoremConjecture);
+        this.context = context;
+        this.string = string;
+        this.node = node;
+        this.labels = labels;
+        this.suppositions = suppositions;
+        this.deduction = deduction;
+        this.proof = proof;
+        this.signature = signature;
+        this.hypotheses = hypotheses;
+    }
+    _create_class(AxiomLemmaTheoremConjecture, [
+        {
+            key: "getContext",
+            value: function getContext() {
+                return this.context;
+            }
+        },
+        {
+            key: "getNode",
+            value: function getNode() {
+                return this.node;
+            }
+        },
+        {
+            key: "getString",
+            value: function getString() {
+                return this.string;
+            }
+        },
+        {
+            key: "getLabels",
+            value: function getLabels() {
+                return this.labels;
+            }
+        },
+        {
+            key: "getSuppositions",
+            value: function getSuppositions() {
+                return this.suppositions;
+            }
+        },
+        {
+            key: "getDeduction",
+            value: function getDeduction() {
+                return this.deduction;
+            }
+        },
+        {
+            key: "getProof",
+            value: function getProof() {
+                return this.proof;
+            }
+        },
+        {
+            key: "getSignature",
+            value: function getSignature() {
+                return this.signature;
+            }
+        },
+        {
+            key: "getHypotheses",
+            value: function getHypotheses() {
+                return this.hypotheses;
+            }
+        },
+        {
+            key: "setHypotheses",
+            value: function setHypotheses(hypotheses) {
+                this.hypotheses = hypotheses;
+            }
+        },
+        {
+            key: "getStatement",
+            value: function getStatement() {
+                return this.deduction.getStatement();
+            }
+        },
+        {
+            key: "isHypothetical",
+            value: function isHypothetical() {
+                var hypothesesLength = this.hypotheses.length, hypothetical = hypothesesLength > 0;
+                return hypothetical;
+            }
+        },
+        {
+            key: "isUnconditional",
+            value: function isUnconditional() {
+                var suppositionsLength = this.suppositions.length, unconditional = suppositionsLength === 0;
+                return unconditional;
+            }
+        },
+        {
+            key: "getSupposition",
+            value: function getSupposition(index) {
+                var supposition = this.suppositions[index] || null;
+                return supposition;
+            }
+        },
+        {
+            key: "matchMetavariableName",
+            value: function matchMetavariableName(metavariableName) {
+                var metavariableNameMatches = this.labels.some(function(label) {
+                    var metavariableNameMatches = label.matchMetavariableName(metavariableName);
+                    if (metavariableNameMatches) {
+                        return true;
+                    }
+                });
+                return metavariableNameMatches;
+            }
+        },
+        {
+            key: "verify",
+            value: function verify() {
+                var verifies = false;
+                var labelsVerify = this.verifyLabels();
+                if (labelsVerify) {
+                    var localContext = _local.default.fromNothing(this.context), context = localContext, suppositionsVerify = this.verifySuppositions(context);
+                    if (suppositionsVerify) {
+                        var deductionVerifies = this.verifyDeduction(context);
+                        if (deductionVerifies) {
+                            var proofVerifies = this.verifyProof(context);
+                            if (proofVerifies) {
+                                verifies = true;
+                            }
+                        }
+                    }
+                }
+                return verifies;
+            }
+        },
+        {
+            key: "verifyLabels",
+            value: function verifyLabels() {
+                var labelsVerify = this.labels.every(function(label) {
+                    var nameOnly = true, labelVerifies = label.verify(nameOnly);
+                    if (labelVerifies) {
+                        return true;
+                    }
+                });
+                return labelsVerify;
+            }
+        },
+        {
+            key: "verifySuppositions",
+            value: function verifySuppositions(context) {
+                var _this = this;
+                var suppositionsVerify = this.suppositions.every(function(supposition) {
+                    var suppositionVerifies = _this.verifySupposition(supposition, context);
+                    if (suppositionVerifies) {
+                        return true;
+                    }
+                });
+                return suppositionsVerify;
+            }
+        },
+        {
+            key: "verifySupposition",
+            value: function verifySupposition(supposition, context) {
+                var suppositionVerifies = supposition.verify(context);
+                return suppositionVerifies;
+            }
+        },
+        {
+            key: "verifyDeduction",
+            value: function verifyDeduction(context) {
+                var deductionVerifies = this.deduction.verify(context);
+                return deductionVerifies;
+            }
+        },
+        {
+            key: "verifyProof",
+            value: function verifyProof(context) {
+                var proofVerifies;
+                if (this.proof === null) {
+                    proofVerifies = true;
+                } else {
+                    var Substitutions = _elements.default.Substitutions, substitutions = Substitutions.fromNothing();
+                    proofVerifies = this.proof.verify(substitutions, this.deduction, context);
+                }
+                return proofVerifies;
+            }
+        },
+        {
+            key: "correlateHypotheses",
+            value: function correlateHypotheses(context) {
+                var hypothesesCorrelate;
+                var hypothetical = this.isHypothetical();
+                if (hypothetical) {
+                    var steps = context.getSteps(), topLevelAssertionString = this.string; ///
+                    context.trace("Correlating the hypotheses of the '".concat(topLevelAssertionString, "' axiom, lemma, theorem or conjecture..."), this.node);
+                    hypothesesCorrelate = correlate(this.hypotheses, steps, function(hypothesis, step) {
+                        var hypothesesEqualToStep = hypothesis.isEqualToStep(step, context);
+                        if (hypothesesEqualToStep) {
+                            return true;
+                        }
+                    });
+                    if (hypothesesCorrelate) {
+                        context.debug("...correlated the hypotheses of the '".concat(topLevelAssertionString, "' axiom, lemma, theorem or conjecture."), this.node);
+                    }
+                } else {
+                    hypothesesCorrelate = true;
+                }
+                return hypothesesCorrelate;
+            }
+        },
+        {
+            key: "unifyStatementWithDeduction",
+            value: function unifyStatementWithDeduction(statement, substitutions, context) {
+                var statementUnifiesWithDeduction = false;
+                var statementUnifies = this.deduction.unifyStatement(statement, substitutions, context); ///
+                if (statementUnifies) {
+                    statementUnifiesWithDeduction = true;
+                }
+                return statementUnifiesWithDeduction;
+            }
+        },
+        {
+            key: "unifyStatementAndStepsOrSubproofs",
+            value: function unifyStatementAndStepsOrSubproofs(statement, stepsOrSubproofs, substitutions, context) {
+                var statementAndStepsOrSubproofsUnifies = false;
+                var hypothesesCorrelate = this.correlateHypotheses(context);
+                if (hypothesesCorrelate) {
+                    var statementUnifiesWithDeduction = this.unifyStatementWithDeduction(statement, substitutions, context);
+                    if (statementUnifiesWithDeduction) {
+                        var stepsOrSubproofsUnifyWithSuppositions = this.unifyStepsOrSubproofsWithSuppositions(stepsOrSubproofs, substitutions, context);
+                        if (stepsOrSubproofsUnifyWithSuppositions) {
+                            var substitutionsResolved = substitutions.areResolved();
+                            if (substitutionsResolved) {
+                                statementAndStepsOrSubproofsUnifies = true;
+                            }
+                        }
+                    }
+                }
+                return statementAndStepsOrSubproofsUnifies;
+            }
+        },
+        {
+            key: "unifyStepsOrSubproofsWithSupposition",
+            value: function unifyStepsOrSubproofsWithSupposition(stepsOrSubproofs, supposition, substitutions, generalContext, specificContext) {
+                var stepsOrSubproofsUnifiesWithSupposition = false;
+                var context = specificContext, suppositionUnifiesIndependently = supposition.unifyIndependently(substitutions, context);
+                if (suppositionUnifiesIndependently) {
+                    stepsOrSubproofsUnifiesWithSupposition = true;
+                } else {
+                    var stepOrSubproof = extract(stepsOrSubproofs, function(stepOrSubproof) {
+                        var stepOrSubproofUnifies = supposition.unifyStepOrSubproof(stepOrSubproof, substitutions, generalContext, specificContext);
+                        if (stepOrSubproofUnifies) {
+                            return true;
+                        }
+                    }) || null;
+                    if (stepOrSubproof !== null) {
+                        stepsOrSubproofsUnifiesWithSupposition = true;
+                    }
+                }
+                return stepsOrSubproofsUnifiesWithSupposition;
+            }
+        },
+        {
+            key: "unifyStepsOrSubproofsWithSuppositions",
+            value: function unifyStepsOrSubproofsWithSuppositions(stepsOrSubproofs, substitutions, generalContext, specificContext) {
+                var _this = this;
+                stepsOrSubproofs = reverse(stepsOrSubproofs); ///
+                var stepsOrSubproofsUnifyWithSuppositions = backwardsEvery(this.suppositions, function(supposition) {
+                    var stepsOrSubproofsUnifiesWithSupposition = _this.unifyStepsOrSubproofsWithSupposition(stepsOrSubproofs, supposition, substitutions, generalContext, specificContext);
+                    if (stepsOrSubproofsUnifiesWithSupposition) {
+                        return true;
+                    }
+                });
+                return stepsOrSubproofsUnifyWithSuppositions;
+            }
+        },
+        {
+            key: "toJSON",
+            value: function toJSON() {
+                var labelsJSON = (0, _json.labelsToLabelsJSON)(this.labels), deductionJSON = (0, _json.deductionToDeductionJSON)(this.deduction), suppositionsJSON = (0, _json.suppositionsToSuppositionsJSON)(this.suppositions), signatureJSON = (0, _json.signatureToSignatureJSON)(this.signature), hypothesesJSON = (0, _json.hypothesesToHypothesesJSON)(this.hypotheses), labels = labelsJSON, deduction = deductionJSON, suppositions = suppositionsJSON, signature = signatureJSON, hypotheses = hypothesesJSON, json = {
+                    labels: labels,
+                    deduction: deduction,
+                    suppositions: suppositions,
+                    signature: signature,
+                    hypotheses: hypotheses
+                };
+                return json;
+            }
+        }
+    ], [
+        {
+            key: "fromJSON",
+            value: function fromJSON(Class, json, context) {
+                var labels = (0, _json.labelsFromJSON)(json, context), deduction = (0, _json.deductionFromJSON)(json, context), suppositions = (0, _json.suppositionsFromJSON)(json, context), signature = (0, _json.signatureFromJSON)(json, context), hypotheses = (0, _json.hypothesesFromJSON)(json, context), node = null, proof = null, string = stringFromLabelsSuppositionsAndDeduction(labels, suppositions, deduction), axiomLemmaTheoremConjecture = new Class(context, string, node, labels, suppositions, deduction, proof, signature, hypotheses);
+                return axiomLemmaTheoremConjecture;
+            }
+        },
+        {
+            key: "fromNode",
+            value: function fromNode(Class, node, context) {
+                var topLevelAssertionNode = node, proofNode = topLevelAssertionNode.getProofNode(), labelNodes = topLevelAssertionNode.getLabelNodes(), deductionNode = topLevelAssertionNode.getDeductionNode(), suppositionNodes = topLevelAssertionNode.getSuppositionNodes(), signatureNode = topLevelAssertionNode.getSignatureNode(), proof = proofFromProofNode(proofNode, context), labels = labelsFromLabelNodes(labelNodes, context), deduction = deductionFromDeductionNode(deductionNode, context), suppositions = suppositionsFromSuppositionNodes(suppositionNodes, context), signature = signatureFromSignatureNode(signatureNode, context), hypotheses = [], string = stringFromLabelsSuppositionsAndDeduction(labels, suppositions, deduction), axiomLemmaTheoremConjecture = new Class(context, string, node, labels, suppositions, deduction, proof, signature, hypotheses);
+                return axiomLemmaTheoremConjecture;
+            }
+        }
+    ]);
+    return AxiomLemmaTheoremConjecture;
+}();
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../src/element/axiomLemmaTheoremConjecture.js"],"sourcesContent":["\"use strict\";\n\nimport { arrayUtilities } from \"necessary\";\n\nimport elements from \"../elements\";\nimport LocalContext from \"../context/local\";\n\nimport { labelsFromJSON,\n         deductionFromJSON,\n         signatureFromJSON,\n         labelsToLabelsJSON,\n         hypothesesFromJSON,\n         suppositionsFromJSON,\n         deductionToDeductionJSON,\n         signatureToSignatureJSON,\n         hypothesesToHypothesesJSON,\n         suppositionsToSuppositionsJSON } from \"../utilities/json\";\n\nconst { extract, reverse, correlate, backwardsEvery } = arrayUtilities;\n\nexport default class AxiomLemmaTheoremConjecture {\n  constructor(context, string, node, labels, suppositions, deduction, proof, signature, hypotheses) {\n    this.context = context;\n    this.string = string;\n    this.node = node;\n    this.labels = labels;\n    this.suppositions = suppositions;\n    this.deduction = deduction;\n    this.proof = proof;\n    this.signature = signature;\n    this.hypotheses = hypotheses;\n  }\n\n  getContext() {\n    return this.context;\n  }\n\n  getNode() {\n    return this.node;\n  }\n\n  getString() {\n    return this.string;\n  }\n\n  getLabels() {\n    return this.labels;\n  }\n\n  getSuppositions() {\n    return this.suppositions;\n  }\n\n  getDeduction() {\n    return this.deduction;\n  }\n\n  getProof() {\n    return this.proof;\n  }\n\n  getSignature() {\n    return this.signature;\n  }\n\n  getHypotheses() {\n    return this.hypotheses;\n  }\n\n  setHypotheses(hypotheses) {\n    this.hypotheses = hypotheses;\n  }\n\n  getStatement() { return this.deduction.getStatement(); }\n\n  isHypothetical() {\n    const hypothesesLength = this.hypotheses.length,\n          hypothetical = (hypothesesLength > 0);\n\n    return hypothetical;\n  }\n\n  isUnconditional() {\n    const suppositionsLength = this.suppositions.length,\n          unconditional = (suppositionsLength === 0);\n\n    return unconditional;\n  }\n\n  getSupposition(index) {\n    const supposition = this.suppositions[index] || null;\n\n    return supposition;\n  }\n\n  matchMetavariableName(metavariableName) {\n    const metavariableNameMatches = this.labels.some((label) => {\n      const metavariableNameMatches = label.matchMetavariableName(metavariableName);\n\n      if (metavariableNameMatches) {\n        return true;\n      }\n    });\n\n    return metavariableNameMatches;\n  }\n\n  verify() {\n    let verifies = false;\n\n    const labelsVerify = this.verifyLabels();\n\n    if (labelsVerify) {\n      const localContext = LocalContext.fromNothing(this.context),\n            context = localContext, ///\n            suppositionsVerify = this.verifySuppositions(context);\n\n      if (suppositionsVerify) {\n        const deductionVerifies = this.verifyDeduction(context);\n\n        if (deductionVerifies) {\n          const proofVerifies = this.verifyProof(context);\n\n          if (proofVerifies) {\n            verifies = true;\n          }\n        }\n      }\n    }\n\n    return verifies;\n  }\n\n  verifyLabels() {\n    const labelsVerify = this.labels.every((label) => {\n      const nameOnly = true,\n            labelVerifies = label.verify(nameOnly);\n\n      if (labelVerifies) {\n        return true;\n      }\n    });\n\n    return labelsVerify;\n  }\n\n  verifySuppositions(context) {\n    const suppositionsVerify = this.suppositions.every((supposition) => {\n      const suppositionVerifies = this.verifySupposition(supposition, context);\n\n      if (suppositionVerifies) {\n        return true;\n      }\n    });\n\n    return suppositionsVerify;\n  }\n\n  verifySupposition(supposition, context) {\n    const suppositionVerifies = supposition.verify(context);\n\n    return suppositionVerifies;\n  }\n\n  verifyDeduction(context) {\n    const deductionVerifies = this.deduction.verify(context);\n\n    return deductionVerifies;\n  }\n\n  verifyProof(context) {\n    let proofVerifies;\n\n    if (this.proof === null) {\n      proofVerifies = true;\n    } else {\n      const { Substitutions } = elements,\n            substitutions = Substitutions.fromNothing();\n\n      proofVerifies = this.proof.verify(substitutions, this.deduction, context);\n    }\n\n    return proofVerifies;\n  }\n\n  correlateHypotheses(context) {\n    let hypothesesCorrelate;\n\n    const hypothetical = this.isHypothetical();\n\n    if (hypothetical) {\n      const steps = context.getSteps(),\n            topLevelAssertionString = this.string;  ///\n\n      context.trace(`Correlating the hypotheses of the '${topLevelAssertionString}' axiom, lemma, theorem or conjecture...`, this.node);\n\n      hypothesesCorrelate = correlate(this.hypotheses, steps, (hypothesis, step) => {\n        const hypothesesEqualToStep = hypothesis.isEqualToStep(step, context);\n\n        if (hypothesesEqualToStep) {\n          return true;\n        }\n      });\n\n      if (hypothesesCorrelate) {\n        context.debug(`...correlated the hypotheses of the '${topLevelAssertionString}' axiom, lemma, theorem or conjecture.`, this.node);\n      }\n    } else {\n      hypothesesCorrelate = true\n    }\n\n    return hypothesesCorrelate;\n  }\n\n  unifyStatementWithDeduction(statement, substitutions, context) {\n    let statementUnifiesWithDeduction = false;\n\n    const statementUnifies = this.deduction.unifyStatement(statement, substitutions, context);  ///\n\n    if (statementUnifies) {\n      statementUnifiesWithDeduction = true;\n    }\n\n    return statementUnifiesWithDeduction;\n  }\n\n  unifyStatementAndStepsOrSubproofs(statement, stepsOrSubproofs, substitutions, context) {\n    let statementAndStepsOrSubproofsUnifies = false;\n\n    const hypothesesCorrelate = this.correlateHypotheses(context);\n\n    if (hypothesesCorrelate) {\n      const statementUnifiesWithDeduction = this.unifyStatementWithDeduction(statement, substitutions, context);\n\n      if (statementUnifiesWithDeduction) {\n        const stepsOrSubproofsUnifyWithSuppositions = this.unifyStepsOrSubproofsWithSuppositions(stepsOrSubproofs, substitutions, context);\n\n        if (stepsOrSubproofsUnifyWithSuppositions) {\n          const substitutionsResolved = substitutions.areResolved();\n\n          if (substitutionsResolved) {\n            statementAndStepsOrSubproofsUnifies = true;\n          }\n        }\n      }\n    }\n\n    return statementAndStepsOrSubproofsUnifies;\n  }\n\n  unifyStepsOrSubproofsWithSupposition(stepsOrSubproofs, supposition, substitutions, generalContext, specificContext) {\n    let stepsOrSubproofsUnifiesWithSupposition = false;\n\n    const context = specificContext,  ///\n          suppositionUnifiesIndependently = supposition.unifyIndependently(substitutions, context);\n\n    if (suppositionUnifiesIndependently) {\n      stepsOrSubproofsUnifiesWithSupposition = true;\n    } else {\n      const stepOrSubproof = extract(stepsOrSubproofs, (stepOrSubproof) => {\n        const stepOrSubproofUnifies = supposition.unifyStepOrSubproof(stepOrSubproof, substitutions, generalContext, specificContext);\n\n        if (stepOrSubproofUnifies) {\n          return true;\n        }\n      }) || null;\n\n      if (stepOrSubproof !== null) {\n        stepsOrSubproofsUnifiesWithSupposition = true;\n      }\n    }\n\n    return stepsOrSubproofsUnifiesWithSupposition;\n  }\n\n  unifyStepsOrSubproofsWithSuppositions(stepsOrSubproofs, substitutions, generalContext, specificContext) {\n    stepsOrSubproofs = reverse(stepsOrSubproofs); ///\n\n    const stepsOrSubproofsUnifyWithSuppositions = backwardsEvery(this.suppositions, (supposition) => {\n      const stepsOrSubproofsUnifiesWithSupposition = this.unifyStepsOrSubproofsWithSupposition(stepsOrSubproofs, supposition, substitutions, generalContext, specificContext);\n\n      if (stepsOrSubproofsUnifiesWithSupposition) {\n        return true;\n      }\n    });\n\n    return stepsOrSubproofsUnifyWithSuppositions;\n  }\n\n  toJSON() {\n    const labelsJSON = labelsToLabelsJSON(this.labels),\n          deductionJSON = deductionToDeductionJSON(this.deduction),\n          suppositionsJSON = suppositionsToSuppositionsJSON(this.suppositions),\n          signatureJSON = signatureToSignatureJSON(this.signature),\n          hypothesesJSON = hypothesesToHypothesesJSON(this.hypotheses),\n          labels = labelsJSON,  ///\n          deduction = deductionJSON,  ///\n          suppositions = suppositionsJSON,  ///\n          signature = signatureJSON,  ///\n          hypotheses = hypothesesJSON,  ///\n          json = {\n            labels,\n            deduction,\n            suppositions,\n            signature,\n            hypotheses\n          };\n\n    return json;\n  }\n\n  static fromJSON(Class, json, context) {\n    const labels = labelsFromJSON(json, context),\n          deduction = deductionFromJSON(json, context),\n          suppositions = suppositionsFromJSON(json, context),\n          signature = signatureFromJSON(json, context),\n          hypotheses = hypothesesFromJSON(json, context),\n          node = null,\n          proof = null,\n          string = stringFromLabelsSuppositionsAndDeduction(labels, suppositions, deduction),\n          axiomLemmaTheoremConjecture = new Class(context, string, node, labels, suppositions, deduction, proof, signature, hypotheses);\n\n    return axiomLemmaTheoremConjecture;\n  }\n\n  static fromNode(Class, node, context) {\n    const topLevelAssertionNode = node, ///\n          proofNode = topLevelAssertionNode.getProofNode(),\n          labelNodes = topLevelAssertionNode.getLabelNodes(),\n          deductionNode = topLevelAssertionNode.getDeductionNode(),\n          suppositionNodes = topLevelAssertionNode.getSuppositionNodes(),\n          signatureNode = topLevelAssertionNode.getSignatureNode(),\n          proof = proofFromProofNode(proofNode, context),\n          labels = labelsFromLabelNodes(labelNodes, context),\n          deduction = deductionFromDeductionNode(deductionNode, context),\n          suppositions = suppositionsFromSuppositionNodes(suppositionNodes, context),\n          signature = signatureFromSignatureNode(signatureNode, context),\n          hypotheses = [],\n          string = stringFromLabelsSuppositionsAndDeduction(labels, suppositions, deduction),\n          axiomLemmaTheoremConjecture = new Class(context, string, node, labels, suppositions, deduction, proof, signature, hypotheses);\n\n    return axiomLemmaTheoremConjecture;\n  }\n}\n"],"names":["AxiomLemmaTheoremConjecture","extract","arrayUtilities","reverse","correlate","backwardsEvery","context","string","node","labels","suppositions","deduction","proof","signature","hypotheses","getContext","getNode","getString","getLabels","getSuppositions","getDeduction","getProof","getSignature","getHypotheses","setHypotheses","getStatement","isHypothetical","hypothesesLength","length","hypothetical","isUnconditional","suppositionsLength","unconditional","getSupposition","index","supposition","matchMetavariableName","metavariableName","metavariableNameMatches","some","label","verify","verifies","labelsVerify","verifyLabels","localContext","LocalContext","fromNothing","suppositionsVerify","verifySuppositions","deductionVerifies","verifyDeduction","proofVerifies","verifyProof","every","nameOnly","labelVerifies","suppositionVerifies","verifySupposition","Substitutions","elements","substitutions","correlateHypotheses","hypothesesCorrelate","steps","getSteps","topLevelAssertionString","trace","hypothesis","step","hypothesesEqualToStep","isEqualToStep","debug","unifyStatementWithDeduction","statement","statementUnifiesWithDeduction","statementUnifies","unifyStatement","unifyStatementAndStepsOrSubproofs","stepsOrSubproofs","statementAndStepsOrSubproofsUnifies","stepsOrSubproofsUnifyWithSuppositions","unifyStepsOrSubproofsWithSuppositions","substitutionsResolved","areResolved","unifyStepsOrSubproofsWithSupposition","generalContext","specificContext","stepsOrSubproofsUnifiesWithSupposition","suppositionUnifiesIndependently","unifyIndependently","stepOrSubproof","stepOrSubproofUnifies","unifyStepOrSubproof","toJSON","labelsJSON","labelsToLabelsJSON","deductionJSON","deductionToDeductionJSON","suppositionsJSON","suppositionsToSuppositionsJSON","signatureJSON","signatureToSignatureJSON","hypothesesJSON","hypothesesToHypothesesJSON","json","fromJSON","Class","labelsFromJSON","deductionFromJSON","suppositionsFromJSON","signatureFromJSON","hypothesesFromJSON","stringFromLabelsSuppositionsAndDeduction","axiomLemmaTheoremConjecture","fromNode","topLevelAssertionNode","proofNode","getProofNode","labelNodes","getLabelNodes","deductionNode","getDeductionNode","suppositionNodes","getSuppositionNodes","signatureNode","getSignatureNode","proofFromProofNode","labelsFromLabelNodes","deductionFromDeductionNode","suppositionsFromSuppositionNodes","signatureFromSignatureNode"],"mappings":"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"}

package/lib/element/conclusion.js

@@ -0,0 +1,151 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return _default;
+    }
+});
+var _temporary = /*#__PURE__*/ _interop_require_default(require("../context/temporary"));
+var _elements = require("../elements");
+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
+    };
+}
+var _Conclusion;
+var _default = (0, _elements.define)((_Conclusion = /*#__PURE__*/ function() {
+    function Conclusion(context, string, node, statement) {
+        _class_call_check(this, Conclusion);
+        this.context = context;
+        this.string = string;
+        this.node = node;
+        this.statement = statement;
+    }
+    _create_class(Conclusion, [
+        {
+            key: "getContext",
+            value: function getContext() {
+                return this.context;
+            }
+        },
+        {
+            key: "getNode",
+            value: function getNode() {
+                return this.node;
+            }
+        },
+        {
+            key: "getString",
+            value: function getString() {
+                return this.string;
+            }
+        },
+        {
+            key: "getStatement",
+            value: function getStatement() {
+                return this.statement;
+            }
+        },
+        {
+            key: "verify",
+            value: function verify(context) {
+                var verifies = false;
+                var temporaryContext = _temporary.default.fromNothing(context);
+                context = temporaryContext; ///
+                var conclusionString = this.string; ///
+                context.trace("Verifying the '".concat(conclusionString, "' conclusion..."), this.node);
+                if (this.statement !== null) {
+                    var stated = true, assignments = null, statementVerifies = this.statement.verify(assignments, stated, context);
+                    verifies = statementVerifies; ///
+                } else {
+                    context.debug("Unable to verify the '".concat(conclusionString, "' conclusion because it is nonsense."), this.node);
+                }
+                if (verifies) {
+                    this.context = context;
+                    context.debug("...verified the '".concat(conclusionString, "' conclusion."), this.node);
+                }
+                return verifies;
+            }
+        },
+        {
+            key: "unifyStatement",
+            value: function unifyStatement(statement, substitutions, context) {
+                var statementUnifies;
+                var conclusion = this, statementString = statement.getString(), conclusionString = conclusion.getString();
+                context.trace("Unifying the '".concat(statementString, "' statement with the '").concat(conclusionString, "' conclusion..."));
+                var generalContext = this.context, specificContext = context; ///
+                statementUnifies = this.statement.unifyStatement(statement, substitutions, generalContext, specificContext);
+                if (statementUnifies) {
+                    context.debug("...unified the '".concat(statementString, "' statement with the '").concat(conclusionString, "' conclusion."));
+                }
+                return statementUnifies;
+            }
+        },
+        {
+            key: "toJSON",
+            value: function toJSON() {
+                var frames, terms;
+                frames = this.context.getFrames();
+                terms = this.context.getTerms();
+                var statementJSON = (0, _json.statementToStatementJSON)(this.statement), framesJSON = (0, _json.framesToFramesJSON)(frames), termsJSON = (0, _json.termsToTermsJSON)(terms);
+                frames = framesJSON; ///
+                terms = termsJSON; ///
+                var statement = statementJSON, json = {
+                    statement: statement,
+                    frames: frames,
+                    terms: terms
+                };
+                return json;
+            }
+        }
+    ], [
+        {
+            key: "fromJSON",
+            value: function fromJSON(json, context) {
+                var terms = (0, _json.termsFromJSON)(json, context), frames = (0, _json.framesFromJSON)(json, context), statement = (0, _json.statementFromJSON)(json, context), node = null, string = statement.getString(), temporaryContext = _temporary.default.fromTermsAndFrames(terms, frames, context);
+                context = temporaryContext; ///
+                var conclusion = new Conclusion(context, string, node, statement);
+                return conclusion;
+            }
+        }
+    ]);
+    return Conclusion;
+}(), _define_property(_Conclusion, "name", "Conclusion"), _Conclusion));
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../src/element/conclusion.js"],"sourcesContent":["\"use strict\";\n\nimport TemporaryContext from \"../context/temporary\";\n\nimport { define } from \"../elements\";\nimport { termsFromJSON, framesFromJSON, statementFromJSON, termsToTermsJSON, framesToFramesJSON, statementToStatementJSON } from \"../utilities/json\";\n\nexport  default define(class Conclusion {\n  constructor(context, string, node, statement) {\n    this.context = context;\n    this.string = string;\n    this.node = node;\n    this.statement = statement;\n  }\n\n  getContext() {\n    return this.context;\n  }\n\n  getNode() {\n    return this.node;\n  }\n\n  getString() {\n    return this.string;\n  }\n\n  getStatement() {\n    return this.statement;\n  }\n\n  verify(context) {\n    let verifies = false;\n\n    const temporaryContext = TemporaryContext.fromNothing(context);\n\n    context = temporaryContext; ///\n\n    const conclusionString = this.string;  ///\n\n    context.trace(`Verifying the '${conclusionString}' conclusion...`, this.node);\n\n    if (this.statement !== null) {\n      const stated = true,\n            assignments = null,\n            statementVerifies = this.statement.verify(assignments, stated, context);\n\n      verifies = statementVerifies; ///\n\n    } else {\n      context.debug(`Unable to verify the '${conclusionString}' conclusion because it is nonsense.`, this.node);\n    }\n\n    if (verifies) {\n      this.context = context;\n\n      context.debug(`...verified the '${conclusionString}' conclusion.`, this.node);\n    }\n\n    return verifies;\n  }\n\n  unifyStatement(statement, substitutions, context) {\n    let statementUnifies;\n\n    const conclusion = this,  ///\n          statementString = statement.getString(),\n          conclusionString = conclusion.getString();\n\n    context.trace(`Unifying the '${statementString}' statement with the '${conclusionString}' conclusion...`);\n\n    const generalContext = this.context,  ///\n          specificContext = context;  ///\n\n    statementUnifies = this.statement.unifyStatement(statement, substitutions, generalContext, specificContext);\n\n    if (statementUnifies) {\n      context.debug(`...unified the '${statementString}' statement with the '${conclusionString}' conclusion.`);\n    }\n\n    return statementUnifies;\n  }\n\n  toJSON() {\n    let frames,\n        terms;\n\n    frames = this.context.getFrames();\n\n    terms = this.context.getTerms();\n\n    const statementJSON = statementToStatementJSON(this.statement),\n          framesJSON = framesToFramesJSON(frames),\n          termsJSON = termsToTermsJSON(terms);\n\n    frames = framesJSON;  ///\n\n    terms = termsJSON;  ///\n\n    const statement = statementJSON,  ///\n          json = {\n            statement,\n            frames,\n            terms\n          };\n\n    return json;\n  }\n\n  static name = \"Conclusion\";\n\n  static fromJSON(json, context) {\n    const terms = termsFromJSON(json, context),\n          frames = framesFromJSON(json, context),\n          statement = statementFromJSON(json, context),\n          node = null,\n          string = statement.getString(),\n          temporaryContext = TemporaryContext.fromTermsAndFrames(terms, frames, context);\n\n    context = temporaryContext; ///\n\n    const conclusion = new Conclusion(context, string, node, statement);\n\n    return conclusion;\n  }\n});\n"],"names":["define","Conclusion","context","string","node","statement","getContext","getNode","getString","getStatement","verify","verifies","temporaryContext","TemporaryContext","fromNothing","conclusionString","trace","stated","assignments","statementVerifies","debug","unifyStatement","substitutions","statementUnifies","conclusion","statementString","generalContext","specificContext","toJSON","frames","terms","getFrames","getTerms","statementJSON","statementToStatementJSON","framesJSON","framesToFramesJSON","termsJSON","termsToTermsJSON","json","fromJSON","termsFromJSON","framesFromJSON","statementFromJSON","fromTermsAndFrames","name"],"mappings":"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"}

package/lib/{ontology → element}/conjecture.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 _Conjecture;
-var _default = (0, _ontology.define)((_Conjecture = /*#__PURE__*/ function(TopLevelAssertion) {
-    _inherits(Conjecture, TopLevelAssertion);
+var _default = (0, _elements.define)((_Conjecture = /*#__PURE__*/ function(AxiomLemmaTheoremConjecture) {
+    _inherits(Conjecture, AxiomLemmaTheoremConjecture);
     function Conjecture() {
         _class_call_check(this, Conjecture);
         return _call_super(this, Conjecture, arguments);
@@ -151,18 +151,11 @@ var _default = (0, _ontology.define)((_Conjecture = /*#__PURE__*/ function(TopLe
         {
             key: "fromJSON",
             value: function fromJSON(json, context) {
-                return _topLevelAssertion.default.fromJSON(Conjecture, json, context);
-            }
-        },
-        {
-            key: "fromConjectureNode",
-            value: function fromConjectureNode(conjectureNode, context) {
-                var node = conjectureNode, conjecture = _topLevelAssertion.default.fromNode(Conjecture, node, context);
-                return conjecture;
+                return _axiomLemmaTheoremConjecture.default.fromJSON(Conjecture, json, context);
             }
         }
     ]);
     return Conjecture;
-}(_topLevelAssertion.default), _define_property(_Conjecture, "name", "Conjecture"), _Conjecture));
+}(_axiomLemmaTheoremConjecture.default), _define_property(_Conjecture, "name", "Conjecture"), _Conjecture));
 
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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