occam-verify-cli 0.0.1111 → 0.0.1114

package/lib/dom/topLevelAssertion.js

@@ -0,0 +1,306 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    default: function() {
+        return TopLevelAssertion;
+    },
+    stringFromLabels: function() {
+        return stringFromLabels;
+    }
+});
+var _necessary = require("necessary");
+var _dom = /*#__PURE__*/ _interop_require_default(require("../dom"));
+var _local = /*#__PURE__*/ _interop_require_default(require("../context/local"));
+var _substitutions = /*#__PURE__*/ _interop_require_default(require("../substitutions"));
+var _constants = require("../constants");
+var _query = require("../utilities/query");
+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 reverse = _necessary.arrayUtilities.reverse, extract = _necessary.arrayUtilities.extract, backwardsEvery = _necessary.arrayUtilities.backwardsEvery;
+var proofNodeQuery = (0, _query.nodeQuery)("/*/proof"), labelNodesQuery = (0, _query.nodesQuery)("/*/label"), consequentNodeQuery = (0, _query.nodeQuery)("/*/consequent"), suppositionNodesQuery = (0, _query.nodesQuery)("/*/supposition");
+var TopLevelAssertion = /*#__PURE__*/ function() {
+    function TopLevelAssertion(fileContext, string, labels, substitutions, suppositions, consequent, proof) {
+        _class_call_check(this, TopLevelAssertion);
+        this.fileContext = fileContext;
+        this.string = string;
+        this.labels = labels;
+        this.substitutions = substitutions;
+        this.suppositions = suppositions;
+        this.consequent = consequent;
+        this.proof = proof;
+    }
+    _create_class(TopLevelAssertion, [
+        {
+            key: "getFileContext",
+            value: function getFileContext() {
+                return this.fileContext;
+            }
+        },
+        {
+            key: "getString",
+            value: function getString() {
+                return this.string;
+            }
+        },
+        {
+            key: "getLabels",
+            value: function getLabels() {
+                return this.labels;
+            }
+        },
+        {
+            key: "getSubstitutions",
+            value: function getSubstitutions() {
+                return this.substitutions;
+            }
+        },
+        {
+            key: "getSuppositions",
+            value: function getSuppositions() {
+                return this.suppositions;
+            }
+        },
+        {
+            key: "getConsequent",
+            value: function getConsequent() {
+                return this.consequent;
+            }
+        },
+        {
+            key: "getProof",
+            value: function getProof() {
+                return this.proof;
+            }
+        },
+        {
+            key: "matchStatementNode",
+            value: function matchStatementNode(statementNode) {
+                return this.consequent.matchStatementNode(statementNode);
+            }
+        },
+        {
+            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: "unifyReference",
+            value: function unifyReference(reference, context) {
+                var referenceUnified;
+                var referenceString = reference.getString(), axiomLemmaTheoremConjecture = this, axiomLemmaTheoremConjectureString = axiomLemmaTheoremConjecture.getString();
+                context.trace("Unifying the '".concat(referenceString, "' reference with the '").concat(axiomLemmaTheoremConjectureString, "' axiom, lemma, theorem or conjecture..."));
+                var substitutions = _substitutions.default.fromNothing(), fileContext = this.getFileContext(), localContext = _local.default.fromFileContext(fileContext), generalContext = localContext, specificContext = context, labelUnified = this.labels.some(function(label) {
+                    substitutions.clear();
+                    var referenceUnified = reference.unifyLabel(label, substitutions, generalContext, specificContext);
+                    if (referenceUnified) {
+                        return true;
+                    }
+                });
+                referenceUnified = labelUnified; ///
+                if (referenceUnified) {
+                    context.debug("...unified the '".concat(referenceString, "' reference with the '").concat(axiomLemmaTheoremConjectureString, "' axiom, lemma, theorem or conjecture."));
+                }
+                return referenceUnified;
+            }
+        },
+        {
+            key: "unifyStatement",
+            value: function unifyStatement(statement, context) {
+                var statementUnified;
+                var statementString = statement.getString(), axiomLemmaTheoremConjecture = this, axiomLemmaTheoremConjectureString = axiomLemmaTheoremConjecture.getString();
+                context.trace("Unifying the '".concat(statementString, "' statement with the '").concat(axiomLemmaTheoremConjectureString, "' axiom, lemma, theorem or conjecture..."));
+                var suppositions = this.getSuppositions(), suppositionsLength = suppositions.length;
+                if (suppositionsLength === 0) {
+                    var substitutions = _substitutions.default.fromNothing(), localContext = _local.default.fromFileContext(this.fileContext), generalContext = localContext, specificContext = context, statementUnifiedWithConsequent = this.unifyStatementWithConsequent(statement, substitutions, generalContext, specificContext);
+                    statementUnified = statementUnifiedWithConsequent; ///
+                }
+                if (statementUnified) {
+                    context.debug("...unified the '".concat(statementString, "' statement with the '").concat(axiomLemmaTheoremConjectureString, "' axiom, lemma, theorem or conjecture."));
+                }
+                return statementUnified;
+            }
+        },
+        {
+            key: "unifyStatementAndProofSteps",
+            value: function unifyStatementAndProofSteps(statement, proofSteps, context) {
+                var statementAndProofStepsUnified;
+                var localContext = _local.default.fromFileContext(this.fileContext), generalContext = localContext, specificContext = context; ///
+                var substitutions = _substitutions.default.fromNothing(), statementUnifiedWithConsequent = this.unifyStatementWithConsequent(statement, substitutions, generalContext, specificContext);
+                if (statementUnifiedWithConsequent) {
+                    var proofStepsUnifiedWithSuppositions = this.unifyProofStepsWithSuppositions(proofSteps, substitutions, generalContext, specificContext);
+                    if (proofStepsUnifiedWithSuppositions) {
+                        var substitutionsResolved = substitutions.areResolved();
+                        statementAndProofStepsUnified = substitutionsResolved; ///
+                    }
+                }
+                return statementAndProofStepsUnified;
+            }
+        },
+        {
+            key: "unifyStatementWithConsequent",
+            value: function unifyStatementWithConsequent(statement, substitutions, generalContext, specificContext) {
+                var consequentUnified;
+                var statementUnified = this.consequent.unifyStatement(statement, substitutions, generalContext, specificContext); ///
+                consequentUnified = statementUnified; ///
+                return consequentUnified;
+            }
+        },
+        {
+            key: "unifyProofStepsWithSuppositions",
+            value: function unifyProofStepsWithSuppositions(proofSteps, substitutions, generalContext, specificContext) {
+                var _this = this;
+                proofSteps = reverse(proofSteps); ///
+                var proofStepsUnifiedWithSuppositions = backwardsEvery(this.suppositions, function(supposition) {
+                    var proofStepsUnifiedWithSupposition = _this.unifyProofStepsWithSupposition(proofSteps, supposition, substitutions, generalContext, specificContext);
+                    if (proofStepsUnifiedWithSupposition) {
+                        return true;
+                    }
+                });
+                return proofStepsUnifiedWithSuppositions;
+            }
+        },
+        {
+            key: "unifyProofStepsWithSupposition",
+            value: function unifyProofStepsWithSupposition(proofSteps, supposition, substitutions, generalContext, specificContext) {
+                var proofStepsUnifiedWithSupposition = false;
+                var suppositionUnifiedIndependently = supposition.unifyIndependently(substitutions, generalContext, specificContext);
+                if (suppositionUnifiedIndependently) {
+                    proofStepsUnifiedWithSupposition = true;
+                } else {
+                    var proofStep = extract(proofSteps, function(proofStep) {
+                        var proofStepUnified = supposition.unifyProofStep(proofStep, substitutions, generalContext, specificContext);
+                        if (proofStepUnified) {
+                            return true;
+                        }
+                    }) || null;
+                    if (proofStep !== null) {
+                        proofStepsUnifiedWithSupposition = true;
+                    }
+                }
+                return proofStepsUnifiedWithSupposition;
+            }
+        },
+        {
+            key: "verify",
+            value: function verify() {
+                var verified = false;
+                var labelsVerified = this.verifyLabels();
+                if (labelsVerified) {
+                    var localContext = _local.default.fromFileContext(this.fileContext), context = localContext, suppositionsVerified = this.suppositions.every(function(supposition) {
+                        var suppositionVerified = supposition.verify(context);
+                        if (suppositionVerified) {
+                            return true;
+                        }
+                    });
+                    if (suppositionsVerified) {
+                        var consequentVerified = this.consequent.verify(context);
+                        if (consequentVerified) {
+                            if (this.proof === null) {
+                                verified = true;
+                            } else {
+                                var proofVerified = this.proof.verify(this.substitutions, this.consequent, context);
+                                verified = proofVerified; ///
+                            }
+                        }
+                    }
+                }
+                return verified;
+            }
+        },
+        {
+            key: "verifyLabels",
+            value: function verifyLabels() {
+                var _this = this;
+                var labelsVerified = this.labels.every(function(label) {
+                    var nameOnly = true, labelVVerifiedWhenDeclared = label.verifyWhenDeclared(_this.fileContext, nameOnly);
+                    if (labelVVerifiedWhenDeclared) {
+                        return true;
+                    }
+                });
+                return labelsVerified;
+            }
+        },
+        {
+            key: "toJSON",
+            value: function toJSON() {
+                var labelsJSON = (0, _json.labelsToLabelsJSON)(this.labels), consequentJSON = (0, _json.consequentToConsequentJSON)(this.consequent), suppositionsJSON = (0, _json.suppositionsToSuppositionsJSON)(this.suppositions), substitutionsJSON = (0, _json.substitutionsToSubstitutionsJSON)(this.substitutions), labels = labelsJSON, consequent = consequentJSON, suppositions = suppositionsJSON, substitutions = substitutionsJSON, json = {
+                    labels: labels,
+                    consequent: consequent,
+                    suppositions: suppositions,
+                    substitutions: substitutions
+                };
+                return json;
+            }
+        }
+    ], [
+        {
+            key: "fromJSON",
+            value: function fromJSON(Class, json, fileContext) {
+                var labels = (0, _json.labelsFromJSON)(json, fileContext), consequent = (0, _json.consequentFromJSON)(json, fileContext), suppositions = (0, _json.suppositionsFromJSON)(json, fileContext), substitutions = (0, _json.substitutionsFromJSON)(json, fileContext), string = stringFromLabels(labels), proof = null, topLevelAssertion = new Class(fileContext, string, labels, substitutions, suppositions, consequent, proof);
+                return topLevelAssertion;
+            }
+        },
+        {
+            key: "fromNode",
+            value: function fromNode(Class, node, fileContext) {
+                var Label = _dom.default.Label, Proof = _dom.default.Proof, Consequent = _dom.default.Consequent, Supposition = _dom.default.Supposition, proofNode = proofNodeQuery(node), labelNodes = labelNodesQuery(node), consequentNode = consequentNodeQuery(node), suppositionNodes = suppositionNodesQuery(node), labels = labelNodes.map(function(labelNode) {
+                    var label = Label.fromLabelNode(labelNode, fileContext);
+                    return label;
+                }), substitutions = _substitutions.default.fromNothing(), suppositions = suppositionNodes.map(function(suppositionNode) {
+                    var supposition = Supposition.fromSuppositionNode(suppositionNode, fileContext);
+                    return supposition;
+                }), consequent = Consequent.fromConsequentNode(consequentNode, fileContext), proof = Proof.fromProofNode(proofNode, fileContext), string = stringFromLabels(labels), metaLemma = new Class(fileContext, string, labels, substitutions, suppositions, consequent, proof);
+                return metaLemma;
+            }
+        }
+    ]);
+    return TopLevelAssertion;
+}();
+function stringFromLabels(labels) {
+    var string = labels.reduce(function(string, label) {
+        var labelString = label.getString();
+        string = string === _constants.EMPTY_STRING ? labelString : "".concat(string, ", ").concat(labelString);
+        return string;
+    }, _constants.EMPTY_STRING);
+    return string;
+}
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../src/dom/topLevelAssertion.js"],"sourcesContent":["\"use strict\";\n\nimport { arrayUtilities } from \"necessary\";\n\nimport dom from \"../dom\";\nimport LocalContext from \"../context/local\";\nimport Substitutions from \"../substitutions\";\n\nimport { EMPTY_STRING } from \"../constants\";\nimport { nodeQuery, nodesQuery } from \"../utilities/query\";\nimport { labelsFromJSON,\n         labelsToLabelsJSON,\n         consequentFromJSON,\n         suppositionsFromJSON,\n         substitutionsFromJSON,\n         consequentToConsequentJSON,\n         suppositionsToSuppositionsJSON,\n         substitutionsToSubstitutionsJSON } from \"../utilities/json\";\n\nconst { reverse, extract, backwardsEvery } = arrayUtilities;\n\nconst proofNodeQuery = nodeQuery(\"/*/proof\"),\n      labelNodesQuery = nodesQuery(\"/*/label\"),\n      consequentNodeQuery = nodeQuery(\"/*/consequent\"),\n      suppositionNodesQuery = nodesQuery(\"/*/supposition\");\n\nexport default class TopLevelAssertion {\n  constructor(fileContext, string, labels, substitutions, suppositions, consequent, proof) {\n    this.fileContext = fileContext;\n    this.string = string;\n    this.labels = labels;\n    this.substitutions = substitutions;\n    this.suppositions = suppositions;\n    this.consequent = consequent;\n    this.proof = proof;\n  }\n\n  getFileContext() {\n    return this.fileContext;\n  }\n\n  getString() {\n    return this.string;\n  }\n\n  getLabels() {\n    return this.labels;\n  }\n\n  getSubstitutions() {\n    return this.substitutions;\n  }\n\n  getSuppositions() {\n    return this.suppositions;\n  }\n\n  getConsequent() {\n    return this.consequent;\n  }\n\n  getProof() {\n    return this.proof;\n  }\n\n  matchStatementNode(statementNode) { return this.consequent.matchStatementNode(statementNode); }\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  unifyReference(reference, context) {\n    let referenceUnified;\n\n    const referenceString = reference.getString(),\n          axiomLemmaTheoremConjecture = this, ///\n          axiomLemmaTheoremConjectureString = axiomLemmaTheoremConjecture.getString();\n\n    context.trace(`Unifying the '${referenceString}' reference with the '${axiomLemmaTheoremConjectureString}' axiom, lemma, theorem or conjecture...`);\n\n    const substitutions = Substitutions.fromNothing(),\n          fileContext = this.getFileContext(),\n          localContext = LocalContext.fromFileContext(fileContext),\n          generalContext = localContext,  ///\n          specificContext = context, ///\n          labelUnified = this.labels.some((label) => {\n            substitutions.clear();\n\n            const referenceUnified = reference.unifyLabel(label, substitutions, generalContext, specificContext);\n\n            if (referenceUnified) {\n              return true;\n            }\n          });\n\n    referenceUnified = labelUnified;  ///\n\n    if (referenceUnified) {\n      context.debug(`...unified the '${referenceString}' reference with the '${axiomLemmaTheoremConjectureString}' axiom, lemma, theorem or conjecture.`);\n    }\n\n    return referenceUnified;\n  }\n\n  unifyStatement(statement, context) {\n    let statementUnified;\n\n    const statementString = statement.getString(),\n          axiomLemmaTheoremConjecture = this, ///\n          axiomLemmaTheoremConjectureString = axiomLemmaTheoremConjecture.getString();\n\n    context.trace(`Unifying the '${statementString}' statement with the '${axiomLemmaTheoremConjectureString}' axiom, lemma, theorem or conjecture...`);\n\n    const suppositions = this.getSuppositions(),\n          suppositionsLength = suppositions.length;\n\n    if (suppositionsLength === 0) {\n      const substitutions = Substitutions.fromNothing(),\n            localContext = LocalContext.fromFileContext(this.fileContext),\n            generalContext = localContext,  ///\n            specificContext = context,  ///\n            statementUnifiedWithConsequent = this.unifyStatementWithConsequent(statement, substitutions, generalContext, specificContext);\n\n      statementUnified = statementUnifiedWithConsequent;  ///\n    }\n\n    if (statementUnified) {\n      context.debug(`...unified the '${statementString}' statement with the '${axiomLemmaTheoremConjectureString}' axiom, lemma, theorem or conjecture.`);\n    }\n\n    return statementUnified;\n  }\n\n  unifyStatementAndProofSteps(statement, proofSteps, context) {\n    let statementAndProofStepsUnified;\n\n    const localContext = LocalContext.fromFileContext(this.fileContext),\n          generalContext = localContext, ///\n          specificContext = context; ///\n\n    const substitutions = Substitutions.fromNothing(),\n          statementUnifiedWithConsequent = this.unifyStatementWithConsequent(statement, substitutions, generalContext, specificContext);\n\n    if (statementUnifiedWithConsequent) {\n      const proofStepsUnifiedWithSuppositions = this.unifyProofStepsWithSuppositions(proofSteps, substitutions, generalContext, specificContext);\n\n      if (proofStepsUnifiedWithSuppositions) {\n        const substitutionsResolved = substitutions.areResolved();\n\n        statementAndProofStepsUnified = substitutionsResolved; ///\n      }\n    }\n\n    return statementAndProofStepsUnified;\n  }\n\n  unifyStatementWithConsequent(statement, substitutions, generalContext, specificContext) {\n    let consequentUnified;\n\n    const statementUnified = this.consequent.unifyStatement(statement, substitutions, generalContext, specificContext);  ///\n\n    consequentUnified = statementUnified; ///\n\n    return consequentUnified;\n  }\n\n  unifyProofStepsWithSuppositions(proofSteps, substitutions, generalContext, specificContext) {\n    proofSteps = reverse(proofSteps); ///\n\n    const proofStepsUnifiedWithSuppositions = backwardsEvery(this.suppositions, (supposition) => {\n      const proofStepsUnifiedWithSupposition = this.unifyProofStepsWithSupposition(proofSteps, supposition, substitutions, generalContext, specificContext);\n\n      if (proofStepsUnifiedWithSupposition) {\n        return true;\n      }\n    });\n\n    return proofStepsUnifiedWithSuppositions;\n  }\n\n  unifyProofStepsWithSupposition(proofSteps, supposition, substitutions, generalContext, specificContext) {\n    let proofStepsUnifiedWithSupposition  =false;\n\n    const suppositionUnifiedIndependently = supposition.unifyIndependently(substitutions, generalContext, specificContext);\n\n    if (suppositionUnifiedIndependently) {\n      proofStepsUnifiedWithSupposition = true;\n    } else {\n      const proofStep = extract(proofSteps, (proofStep) => {\n        const proofStepUnified = supposition.unifyProofStep(proofStep, substitutions, generalContext, specificContext);\n\n        if (proofStepUnified) {\n          return true;\n        }\n      }) || null;\n\n      if (proofStep !== null) {\n        proofStepsUnifiedWithSupposition = true;\n      }\n    }\n\n    return proofStepsUnifiedWithSupposition;\n  }\n\n  verify() {\n    let verified = false;\n\n    const labelsVerified = this.verifyLabels();\n\n    if (labelsVerified) {\n      const localContext = LocalContext.fromFileContext(this.fileContext),\n            context = localContext, ///\n            suppositionsVerified = this.suppositions.every((supposition) => {\n              const suppositionVerified = supposition.verify(context);\n\n              if (suppositionVerified) {\n                return true;\n              }\n            });\n\n      if (suppositionsVerified) {\n        const consequentVerified = this.consequent.verify(context);\n\n        if (consequentVerified) {\n          if (this.proof === null) {\n            verified = true;\n          } else {\n            const proofVerified = this.proof.verify(this.substitutions, this.consequent, context);\n\n            verified = proofVerified; ///\n          }\n        }\n      }\n    }\n\n    return verified;\n  }\n\n  verifyLabels() {\n    const labelsVerified = this.labels.every((label) => {\n      const nameOnly = true,\n            labelVVerifiedWhenDeclared = label.verifyWhenDeclared(this.fileContext, nameOnly);\n\n      if (labelVVerifiedWhenDeclared) {\n        return true;\n      }\n    });\n\n    return labelsVerified;\n  }\n\n  toJSON() {\n    const labelsJSON = labelsToLabelsJSON(this.labels),\n          consequentJSON = consequentToConsequentJSON(this.consequent),\n          suppositionsJSON = suppositionsToSuppositionsJSON(this.suppositions),\n          substitutionsJSON = substitutionsToSubstitutionsJSON(this.substitutions),\n          labels = labelsJSON,  ///\n          consequent = consequentJSON,  ///\n          suppositions = suppositionsJSON,  ///\n          substitutions = substitutionsJSON,  ///\n          json = {\n            labels,\n            consequent,\n            suppositions,\n            substitutions\n          };\n\n    return json;\n  }\n\n  static fromJSON(Class, json, fileContext) {\n    const labels = labelsFromJSON(json, fileContext),\n          consequent = consequentFromJSON(json, fileContext),\n          suppositions = suppositionsFromJSON(json, fileContext),\n          substitutions = substitutionsFromJSON(json, fileContext),\n          string = stringFromLabels(labels),\n          proof = null,\n          topLevelAssertion = new Class(fileContext, string, labels, substitutions, suppositions, consequent, proof);\n\n    return topLevelAssertion;\n  }\n\n  static fromNode(Class, node, fileContext) {\n    const { Label, Proof, Consequent, Supposition } = dom,\n          proofNode = proofNodeQuery(node),\n          labelNodes = labelNodesQuery(node),\n          consequentNode = consequentNodeQuery(node),\n          suppositionNodes = suppositionNodesQuery(node),\n          labels = labelNodes.map((labelNode) => {\n            const label = Label.fromLabelNode(labelNode, fileContext);\n\n            return label;\n          }),\n          substitutions = Substitutions.fromNothing(),\n          suppositions = suppositionNodes.map((suppositionNode) => {\n            const supposition = Supposition.fromSuppositionNode(suppositionNode, fileContext);\n\n            return supposition;\n          }),\n          consequent = Consequent.fromConsequentNode(consequentNode, fileContext),\n          proof = Proof.fromProofNode(proofNode, fileContext),\n          string = stringFromLabels(labels),\n          metaLemma = new Class(fileContext, string, labels, substitutions, suppositions, consequent, proof);\n\n    return metaLemma;\n  }\n}\n\nexport function stringFromLabels(labels) {\n  const string = labels.reduce((string, label) => {\n    const labelString = label.getString();\n\n    string = (string === EMPTY_STRING) ?\n               labelString: ///\n                 `${string}, ${labelString}`;\n\n    return string;\n  }, EMPTY_STRING);\n\n  return string;\n}\n\n"],"names":["TopLevelAssertion","stringFromLabels","reverse","arrayUtilities","extract","backwardsEvery","proofNodeQuery","nodeQuery","labelNodesQuery","nodesQuery","consequentNodeQuery","suppositionNodesQuery","fileContext","string","labels","substitutions","suppositions","consequent","proof","getFileContext","getString","getLabels","getSubstitutions","getSuppositions","getConsequent","getProof","matchStatementNode","statementNode","matchMetavariableName","metavariableName","metavariableNameMatches","some","label","unifyReference","reference","context","referenceUnified","referenceString","axiomLemmaTheoremConjecture","axiomLemmaTheoremConjectureString","trace","Substitutions","fromNothing","localContext","LocalContext","fromFileContext","generalContext","specificContext","labelUnified","clear","unifyLabel","debug","unifyStatement","statement","statementUnified","statementString","suppositionsLength","length","statementUnifiedWithConsequent","unifyStatementWithConsequent","unifyStatementAndProofSteps","proofSteps","statementAndProofStepsUnified","proofStepsUnifiedWithSuppositions","unifyProofStepsWithSuppositions","substitutionsResolved","areResolved","consequentUnified","supposition","proofStepsUnifiedWithSupposition","unifyProofStepsWithSupposition","suppositionUnifiedIndependently","unifyIndependently","proofStep","proofStepUnified","unifyProofStep","verify","verified","labelsVerified","verifyLabels","suppositionsVerified","every","suppositionVerified","consequentVerified","proofVerified","nameOnly","labelVVerifiedWhenDeclared","verifyWhenDeclared","toJSON","labelsJSON","labelsToLabelsJSON","consequentJSON","consequentToConsequentJSON","suppositionsJSON","suppositionsToSuppositionsJSON","substitutionsJSON","substitutionsToSubstitutionsJSON","json","fromJSON","Class","labelsFromJSON","consequentFromJSON","suppositionsFromJSON","substitutionsFromJSON","topLevelAssertion","fromNode","node","Label","dom","Proof","Consequent","Supposition","proofNode","labelNodes","consequentNode","suppositionNodes","map","labelNode","fromLabelNode","suppositionNode","fromSuppositionNode","fromConsequentNode","fromProofNode","metaLemma","reduce","labelString","EMPTY_STRING"],"mappings":"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"}