occam-verify-cli 1.0.852 → 1.0.857

package/lib/context/mnemic.js

@@ -0,0 +1,511 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return MnemicContext;
+    }
+});
+const _necessary = require("necessary");
+const _context = /*#__PURE__*/ _interop_require_default(require("../context"));
+const _synoptic = require("../utilities/synoptic");
+const _json = require("../utilities/json");
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+const { push } = _necessary.arrayUtilities;
+class MnemicContext extends _context.default {
+    constructor(context, terms, frames, equalities, judgements, assertions, statements, references, assumptions, metavariables, substitutions){
+        super(context);
+        this.terms = terms;
+        this.frames = frames;
+        this.equalities = equalities;
+        this.judgements = judgements;
+        this.assertions = assertions;
+        this.statements = statements;
+        this.references = references;
+        this.assumptions = assumptions;
+        this.metavariables = metavariables;
+        this.substitutions = substitutions;
+    }
+    getTerms(terms = []) {
+        const context = this.getContext();
+        push(terms, this.terms);
+        context.getTerms(terms);
+        (0, _synoptic.compressTerms)(context);
+        return terms;
+    }
+    getFrames(frames = []) {
+        const context = this.getContext();
+        push(frames, this.frames);
+        context.getFrames(frames);
+        (0, _synoptic.compressFrames)(context);
+        return frames;
+    }
+    getEqualities(equalities = []) {
+        const context = this.getContext();
+        push(equalities, this.equalities);
+        context.getEqualities(equalities);
+        (0, _synoptic.compressEqualities)(context);
+        return equalities;
+    }
+    getJudgements(judgements = []) {
+        const context = this.getContext();
+        push(judgements, this.judgements);
+        context.getJudgements(judgements);
+        (0, _synoptic.compressJudgements)(context);
+        return judgements;
+    }
+    getStatements(statements = []) {
+        const context = this.getContext();
+        push(statements, this.statements);
+        context.getStatements(statements);
+        (0, _synoptic.compressStatements)(context);
+        return statements;
+    }
+    getAssertions(assertions = []) {
+        const context = this.getContext();
+        push(assertions, this.assertions);
+        context.getAssertions(assertions);
+        (0, _synoptic.compressAssertions)(context);
+        return assertions;
+    }
+    getReferences(references = []) {
+        const context = this.getContext();
+        push(references, this.references);
+        context.getReferences(references);
+        (0, _synoptic.compressReferences)(context);
+        return references;
+    }
+    getAssumptions(assumptions = []) {
+        const context = this.getContext();
+        push(assumptions, this.assumptions);
+        context.getAssumptions(assumptions);
+        (0, _synoptic.compressAssumptions)(context);
+        return assumptions;
+    }
+    getMetavariables(metavariables = []) {
+        const context = this.getContext();
+        push(metavariables, this.metavariables);
+        context.getMetavariables(metavariables);
+        (0, _synoptic.compressMetavariables)(context);
+        return metavariables;
+    }
+    getSubstitutions(substitutions = []) {
+        const context = this.getContext();
+        push(substitutions, this.substitutions);
+        context.getSubstitutions(substitutions);
+        (0, _synoptic.compressSubstitutions)(context);
+        return substitutions;
+    }
+    addTerm(term) {
+        const context = this, termA = term, termString = term.getString();
+        context.trace(`Adding the '${termString}' term to the mnemic context...`);
+        const terms = this.getTerms(), termB = terms.find((term)=>{
+            const termB = term, termAComparesToTermB = termA.compareTerm(termB);
+            if (termAComparesToTermB) {
+                return true;
+            }
+        }) || null;
+        if (termB !== null) {
+            context.trace(`The '${termString}' term has already been added to the mnemic context.`);
+        } else {
+            this.terms.push(term);
+        }
+        context.debug(`...added the '${termString}' term to the mnemic context.`);
+    }
+    addFrame(frame) {
+        const context = this, frameA = frame, frameString = frame.getString();
+        context.trace(`Adding the '${frameString}' frame to the mnemic context...`);
+        const frames = this.getFrames(), frameB = frames.find((frame)=>{
+            const frameB = frame, frameAEqualToFrameB = frameA.isEqualTo(frameB);
+            if (frameAEqualToFrameB) {
+                return true;
+            }
+        }) || null;
+        if (frameB !== null) {
+            context.trace(`The '${frameString}' frame has already been added to the mnemic context.`);
+        } else {
+            this.frames.push(frame);
+        }
+        context.debug(`...added the '${frameString}' frame to the mnemic context.`);
+    }
+    addEquality(equality) {
+        const context = this, equalityA = equality, equalityString = equality.getString();
+        context.trace(`Adding the '${equalityString}' equality to the mnemic context...`);
+        const equalities = this.getEqualities(), equalityB = equalities.find((equality)=>{
+            const equalityB = equality, equalityAEqualToEqualityB = equalityA.isEqualTo(equalityB);
+            if (equalityAEqualToEqualityB) {
+                return true;
+            }
+        }) || null;
+        if (equalityB !== null) {
+            context.trace(`The '${equalityString}' equality has already been added to the mnemic context.`);
+        } else {
+            this.equalities.push(equality);
+        }
+        context.debug(`...added the '${equalityString}' equality to the mnemic context.`);
+    }
+    addJudgement(judgement) {
+        const context = this, judgementA = judgement, judgementString = judgement.getString();
+        context.trace(`Adding the '${judgementString}' judgement to the mnemic context...`);
+        const judgements = this.getJudgements(), judgementB = judgements.find((judgement)=>{
+            const judgementB = judgement, judgementAEqualToEqualityB = judgementA.isEqualTo(judgementB);
+            if (judgementAEqualToEqualityB) {
+                return true;
+            }
+        }) || null;
+        if (judgementB !== null) {
+            context.trace(`The '${judgementString}' judgement has already been added to the mnemic context.`);
+        } else {
+            this.judgements.push(judgement);
+        }
+        context.debug(`...added the '${judgementString}' judgement to the mnemic context.`);
+    }
+    addStatement(statement) {
+        const context = this, statementA = statement, statementString = statement.getString();
+        context.trace(`Adding the '${statementString}' statement to the mnemic context...`);
+        const statements = this.getStatements(), statementB = statements.find((statement)=>{
+            const statementB = statement, statementAEqualToStatementB = statementA.isEqualTo(statementB);
+            if (statementAEqualToStatementB) {
+                return true;
+            }
+        }) || null;
+        if (statementB !== null) {
+            context.trace(`The '${statementString}' statement has already been added to the mnemic context.`);
+        } else {
+            this.statements.push(statement);
+        }
+        context.debug(`...added the '${statementString}' statement to the mnemic context.`);
+    }
+    addAssertion(assertion) {
+        const context = this, assertionA = assertion, assertionString = assertion.getString();
+        context.trace(`Adding the '${assertionString}' assertion to the mnemic context...`);
+        const assertions = this.getAssumptions(), assertionB = assertions.find((assertion)=>{
+            const assertionB = assertion, assertionAEqualToAssertionB = assertionA.isEqualTo(assertionB);
+            if (assertionAEqualToAssertionB) {
+                return true;
+            }
+        }) || null;
+        if (assertionB !== null) {
+            context.trace(`The '${assertionString}' assertion has already been added to the mnemic context.`);
+        } else {
+            this.assertions.push(assertion);
+        }
+        context.debug(`...added the '${assertionString}' assertion to the mnemic context.`);
+    }
+    addReference(reference) {
+        const context = this, referenceA = reference, referenceString = reference.getString();
+        context.trace(`Adding the '${referenceString}' reference to the mnemic context...`);
+        const references = this.getReferences(), referenceB = references.find((reference)=>{
+            const referenceB = reference, referenceAEqualToReferenceB = referenceA.isEqualTo(referenceB);
+            if (referenceAEqualToReferenceB) {
+                return true;
+            }
+        }) || null;
+        if (referenceB !== null) {
+            context.trace(`The '${referenceString}' reference has already been added to the mnemic context.`);
+        } else {
+            this.references.push(reference);
+        }
+        context.debug(`...added the '${referenceString}' reference to the mnemic context.`);
+    }
+    addAssumption(assumption) {
+        const context = this, assumptionA = assumption, assumptionString = assumption.getString();
+        context.trace(`Adding the '${assumptionString}' assumption to the mnemic context...`);
+        const assumptions = this.getAssumptions(), assumptionB = assumptions.find((assumption)=>{
+            const assumptionB = assumption, assumptionAEqualToAssumptionB = assumptionA.isEqualTo(assumptionB);
+            if (assumptionAEqualToAssumptionB) {
+                return true;
+            }
+        }) || null;
+        if (assumptionB !== null) {
+            context.trace(`The '${assumptionString}' assumption has already been added to the mnemic context.`);
+        } else {
+            this.assumptions.push(assumption);
+        }
+        context.debug(`...added the '${assumptionString}' assumption to the mnemic context.`);
+    }
+    addMetavariable(metavariable) {
+        const context = this, metavariableA = metavariable, metavariableString = metavariable.getString();
+        context.trace(`Adding the '${metavariableString}' metavariable to the mnemic context...`);
+        const metavariables = this.getMetavariables(), metavariableB = metavariables.find((metavariable)=>{
+            const metavariableB = metavariable, metavariableAEqualToSubstitutionB = metavariableA.isEqualTo(metavariableB);
+            if (metavariableAEqualToSubstitutionB) {
+                return true;
+            }
+        }) || null;
+        if (metavariableB !== null) {
+            context.trace(`The '${metavariableString}' metavariable has already been added to the mnemic context.`);
+        } else {
+            this.metavariables.push(metavariable);
+        }
+        context.debug(`...added the '${metavariableString}' metavariable to the mnemic context.`);
+    }
+    addSubstitution(substitution) {
+        const context = this, substitutionA = substitution, substitutionString = substitution.getString();
+        context.trace(`Adding the '${substitutionString}' substitution to the mnemic context...`);
+        const substitutions = this.getSubstitutions(), substitutionB = substitutions.find((substitution)=>{
+            const substitutionB = substitution, substitutionAEqualToSubstitutionB = substitutionA.isEqualTo(substitutionB);
+            if (substitutionAEqualToSubstitutionB) {
+                return true;
+            }
+        }) || null;
+        if (substitutionB !== null) {
+            context.trace(`The '${substitutionString}' substitution has already been added to the mnemic context.`);
+        } else {
+            this.substitutions.push(substitution);
+        }
+        context.debug(`...added the '${substitutionString}' substitution to the mnemic context.`);
+    }
+    addTerms(terms) {
+        terms.forEach((term)=>{
+            this.addTerm(term);
+        });
+    }
+    addFrames(frames) {
+        frames.forEach((frame)=>{
+            this.addFrame(frame);
+        });
+    }
+    addEqualities(equalities) {
+        equalities.forEach((equality)=>{
+            this.addEquality(equality);
+        });
+    }
+    addJudgements(judgements) {
+        judgements.forEach((judgement)=>{
+            this.addJudgement(judgement);
+        });
+    }
+    addAssertions(assertions) {
+        assertions.forEach((assertion)=>{
+            this.addAssertion(assertion);
+        });
+    }
+    addStatements(statements) {
+        statements.forEach((statement)=>{
+            this.addStatement(statement);
+        });
+    }
+    addReferences(references) {
+        references.forEach((reference)=>{
+            this.addReference(reference);
+        });
+    }
+    addAssumptions(assumptions) {
+        assumptions.forEach((assumption)=>{
+            this.addAssumption(assumption);
+        });
+    }
+    addMetavariables(metavariables) {
+        metavariables.forEach((metavariable)=>{
+            this.addMetavariable(metavariable);
+        });
+    }
+    addSubstitutions(substitutions) {
+    ///
+    }
+    findVariableByVariableNode(variableNode) {
+        const variableIdentifier = variableNode.getVariableIdentifier(), declaredVariable = this.findDeclaredVariableByVariableIdentifier(variableIdentifier), variable = declaredVariable; ///
+        return variable;
+    }
+    findTermByTermNode(termNode) {
+        const terms = this.getTerms(), term = terms.find((term)=>{
+            const termNodeMatches = term.matchTermNode(termNode);
+            if (termNodeMatches) {
+                return true;
+            }
+        }) || null;
+        return term;
+    }
+    findFrameByFrameNode(frameNode) {
+        const frames = this.getFrames(), frame = frames.find((frame)=>{
+            const frameNodeMatches = frame.matchFrameNode(frameNode);
+            if (frameNodeMatches) {
+                return true;
+            }
+        }) || null;
+        return frame;
+    }
+    findEqualityByEqualityNode(equalityNode) {
+        const equalities = this.getEqualities(), equality = equalities.find((equality)=>{
+            const equalityNodeMatches = equality.matchEqualityNode(equalityNode);
+            if (equalityNodeMatches) {
+                return true;
+            }
+        }) || null;
+        return equality;
+    }
+    findJudgementByJudgementNode(judgementNode) {
+        const judgements = this.getJudgements(), judgement = judgements.find((judgement)=>{
+            const judgementNodeMatches = judgement.matchJudgementNode(judgementNode);
+            if (judgementNodeMatches) {
+                return true;
+            }
+        }) || null;
+        return judgement;
+    }
+    findStatementByStatementNode(statementNode) {
+        const statements = this.getStatements(), statement = statements.find((statement)=>{
+            const statementNodeMatches = statement.matchStatementNode(statementNode);
+            if (statementNodeMatches) {
+                return true;
+            }
+        }) || null;
+        return statement;
+    }
+    findReferenceByReferenceNode(referenceNode) {
+        const references = this.getReferences(), reference = references.find((reference)=>{
+            const referenceMatcheReferenceNode = reference.matchReferenceNode(referenceNode);
+            if (referenceMatcheReferenceNode) {
+                return true;
+            }
+        }) || null;
+        return reference;
+    }
+    findAssertionByAssertionNode(assertionNode) {
+        const assertions = this.getAssertions(), assertion = assertions.find((assertion)=>{
+            const assertionNodeMatches = assertion.matchAssertionNode(assertionNode);
+            if (assertionNodeMatches) {
+                return true;
+            }
+        }) || null;
+        return assertion;
+    }
+    findAssumptionByAssumptionNode(assumptionNode) {
+        const assumptions = this.getAssumptions(), assumption = assumptions.find((assumption)=>{
+            const assumptionNodeMatches = assumption.matchAssumptionNode(assumptionNode);
+            if (assumptionNodeMatches) {
+                return true;
+            }
+        }) || null;
+        return assumption;
+    }
+    findReferenceByMetavariableNode(metavariableNode) {
+        const references = this.getReferences(), reference = references.find((reference)=>{
+            const referenceMatcheMetavariableNode = reference.matchMetavariableNode(metavariableNode);
+            if (referenceMatcheMetavariableNode) {
+                return true;
+            }
+        }) || null;
+        return reference;
+    }
+    findMetavariableByMetavariableNode(metavariableNode) {
+        const metavariables = this.getMetavariables(), metavariable = metavariables.find((metavariable)=>{
+            const metavariableNodeMatches = metavariable.matchMetavariableNode(metavariableNode);
+            if (metavariableNodeMatches) {
+                return true;
+            }
+        }) || null;
+        return metavariable;
+    }
+    findSubstitutionBySubstitutionNode(substitutionNode) {
+        const substitutions = this.getSubstitutions(), substitution = substitutions.find((substitution)=>{
+            const substitutionNodeMatches = substitution.matchSubstitutionNode(substitutionNode);
+            if (substitutionNodeMatches) {
+                return true;
+            }
+        }) || null;
+        return substitution;
+    }
+    isTermPresentByTermNode(termNode) {
+        const term = this.findTermByTermNode(termNode), termPresent = term !== null;
+        return termPresent;
+    }
+    isFramePresentByFrameNode(frameNode) {
+        const frame = this.findFrameByFrameNode(frameNode), framePresent = frame !== null;
+        return framePresent;
+    }
+    isEqualityPresentByEqualityNode(equalityNode) {
+        const equality = this.findEqualityByEqualityNode(equalityNode), equalityPresent = equality !== null;
+        return equalityPresent;
+    }
+    isJudgementPresentByJudgementNode(judgementNode) {
+        const judgement = this.findJudgementByJudgementNode(judgementNode), judgementPresent = judgement !== null;
+        return judgementPresent;
+    }
+    isStatementPresentByStatementNode(statementNode) {
+        const statement = this.findStatementByStatementNode(statementNode), statementPresent = statement !== null;
+        return statementPresent;
+    }
+    isAssertionPresentByAssertionNode(assertionNode) {
+        const assertion = this.findAssertionByAssertionNode(assertionNode), assertionPresent = assertion !== null;
+        return assertionPresent;
+    }
+    isAssumptionPresentByAssumptionNode(assumptionNode) {
+        const assumption = this.findAssumptionByAssumptionNode(assumptionNode), assumptionPresent = assumption !== null;
+        return assumptionPresent;
+    }
+    isReferencePresentByMetavariableNode(metavariableNode) {
+        const reference = this.findReferenceByMetavariableNode(metavariableNode), referencePresent = reference !== null;
+        return referencePresent;
+    }
+    isMetavariablePresentByMetavariableNode(metavariablenNode) {
+        const metavariablen = this.findMetavariableByMetavariableNode(metavariablenNode), metavariablenPresent = metavariablen !== null;
+        return metavariablenPresent;
+    }
+    isSubstitutionPresentBySubstitutionNode(substitutionNode) {
+        const substitution = this.findSubstitutionBySubstitutionNode(substitutionNode), substitutionPresent = substitution !== null;
+        return substitutionPresent;
+    }
+    commit(element) {
+        const context = this; ///
+        element.setContext(context);
+    }
+    initialise(json) {
+        const context = this; ///
+        this.terms = (0, _json.termsFromJSON)(json, context);
+        this.metavariables = (0, _json.metavariablesFromJSON)(json, context);
+        this.statements = (0, _json.statementsFromJSON)(json, context);
+        this.references = (0, _json.referencesFromJSON)(json, context);
+        this.equalities = (0, _json.equalitiesFromJSON)(json, context);
+        this.assumptions = (0, _json.assumptionsFromJSON)(json, context);
+        this.frames = (0, _json.framesFromJSON)(json, context);
+        this.judgements = (0, _json.judgementsFromJSON)(json, context);
+        this.assertions = (0, _json.assertionsFromJSON)(json, context);
+        this.substitutions = (0, _json.substitutionsFromJSON)(json, context);
+    }
+    toJSON() {
+        let terms = this.getTerms(), frames = this.getFrames(), judgements = this.getJudgements(), equalities = this.getEqualities(), statements = this.getStatements(), assertions = this.getAssertions(), references = this.getReferences(), assumptions = this.getAssumptions(), metavariables = this.getMetavariables(), substitutions = this.getSubstitutions();
+        const termsJSON = (0, _json.termsToTermsJSON)(terms), framesJSON = (0, _json.framesToFramesJSON)(frames), judgementsJSON = (0, _json.judgementsToJudgementsJSON)(judgements), equalitiesJSON = (0, _json.equalitiesToEqualitiesJSON)(equalities), statementsJSON = (0, _json.statementsToStatementsJSON)(statements), assertionsJSON = (0, _json.assertionsToAssertionsJSON)(assertions), referencesJSON = (0, _json.referencesToReferencesJSON)(references), assumptionsJSON = (0, _json.assumptionsToAssumptionsJSON)(assumptions), metavariablesJSON = (0, _json.metavariablesToMetavariablesJSON)(metavariables), substitutionsJSON = (0, _json.substitutionsToSubstitutionsJSON)(substitutions);
+        terms = termsJSON; ///
+        frames = framesJSON; ///
+        judgements = judgementsJSON; ///
+        equalities = equalitiesJSON; ///
+        statements = statementsJSON; ///
+        assertions = assertionsJSON; ///
+        references = referencesJSON; ///
+        assumptions = assumptionsJSON; ///
+        metavariables = metavariablesJSON; //
+        substitutions = substitutionsJSON; ///
+        const json = {
+            terms,
+            frames,
+            judgements,
+            equalities,
+            statements,
+            assertions,
+            references,
+            assumptions,
+            metavariables,
+            substitutions
+        };
+        return json;
+    }
+    static fromJSON(json, context) {
+        const terms = null, frames = null, equalities = null, judgements = null, statements = null, assertions = null, references = null, assumptions = null, metavariables = null, substitutions = null, mnemicContext = new MnemicContext(context, terms, frames, equalities, judgements, assertions, statements, references, assumptions, metavariables, substitutions);
+        mnemicContext.initialise(json);
+        return mnemicContext;
+    }
+    static fromNothing(context) {
+        const terms = [], frames = [], equalities = [], judgements = [], statements = [], assertions = [], references = [], assumptions = [], metavariables = [], substitutions = [], mnemicContext = new MnemicContext(context, terms, frames, equalities, judgements, assertions, statements, references, assumptions, metavariables, substitutions);
+        return mnemicContext;
+    }
+}
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../src/context/mnemic.js"],"sourcesContent":["\"use strict\";\n\nimport { arrayUtilities } from \"necessary\";\n\nimport Context from \"../context\";\n\nimport { compressTerms,\n         compressFrames,\n         compressEqualities,\n         compressJudgements,\n         compressAssertions,\n         compressStatements,\n         compressReferences,\n         compressAssumptions,\n         compressMetavariables,\n         compressSubstitutions,} from \"../utilities/synoptic\";\nimport { termsFromJSON,\n         framesFromJSON,\n         termsToTermsJSON,\n         framesToFramesJSON,\n         judgementsFromJSON,\n         equalitiesFromJSON,\n         statementsFromJSON,\n         assertionsFromJSON,\n         referencesFromJSON,\n         assumptionsFromJSON,\n         metavariablesFromJSON,\n         substitutionsFromJSON,\n         judgementsToJudgementsJSON,\n         equalitiesToEqualitiesJSON,\n         statementsToStatementsJSON,\n         assertionsToAssertionsJSON,\n         referencesToReferencesJSON,\n         assumptionsToAssumptionsJSON,\n         metavariablesToMetavariablesJSON,\n         substitutionsToSubstitutionsJSON } from \"../utilities/json\";\n\nconst { push } = arrayUtilities;\n\nexport default class MnemicContext extends Context {\n  constructor(context, terms, frames, equalities, judgements, assertions, statements, references, assumptions, metavariables, substitutions) {\n    super(context);\n\n    this.terms = terms;\n    this.frames = frames;\n    this.equalities = equalities;\n    this.judgements = judgements;\n    this.assertions = assertions;\n    this.statements = statements;\n    this.references = references;\n    this.assumptions = assumptions;\n    this.metavariables = metavariables;\n    this.substitutions = substitutions;\n  }\n\n  getTerms(terms = []) {\n    const context = this.getContext();\n\n    push(terms, this.terms);\n\n    context.getTerms(terms);\n\n    compressTerms(context);\n\n    return terms;\n  }\n\n  getFrames(frames = []) {\n    const context = this.getContext();\n\n    push(frames, this.frames);\n\n    context.getFrames(frames);\n\n    compressFrames(context);\n\n    return frames;\n  }\n\n  getEqualities(equalities = []) {\n    const context = this.getContext();\n\n    push(equalities, this.equalities);\n\n    context.getEqualities(equalities);\n\n    compressEqualities(context);\n\n    return equalities;\n  }\n\n  getJudgements(judgements = []) {\n    const context = this.getContext();\n\n    push(judgements, this.judgements);\n\n    context.getJudgements(judgements);\n\n    compressJudgements(context);\n\n    return judgements;\n  }\n\n  getStatements(statements = []) {\n    const context = this.getContext();\n\n    push(statements, this.statements);\n\n    context.getStatements(statements);\n\n    compressStatements(context);\n\n    return statements;\n  }\n\n  getAssertions(assertions = []) {\n    const context = this.getContext();\n\n    push(assertions, this.assertions);\n\n    context.getAssertions(assertions);\n\n    compressAssertions(context);\n\n    return assertions;\n  }\n\n  getReferences(references = []) {\n    const context = this.getContext();\n\n    push(references, this.references);\n\n    context.getReferences(references);\n\n    compressReferences(context);\n\n    return references;\n  }\n\n  getAssumptions(assumptions = []) {\n    const context = this.getContext();\n\n    push(assumptions, this.assumptions);\n\n    context.getAssumptions(assumptions);\n\n    compressAssumptions(context);\n\n    return assumptions;\n  }\n\n  getMetavariables(metavariables = []) {\n    const context = this.getContext();\n\n    push(metavariables, this.metavariables);\n\n    context.getMetavariables(metavariables);\n\n    compressMetavariables(context);\n\n    return metavariables;\n  }\n\n  getSubstitutions(substitutions = []) {\n    const context = this.getContext();\n\n    push(substitutions, this.substitutions);\n\n    context.getSubstitutions(substitutions);\n\n    compressSubstitutions(context);\n\n    return substitutions;\n  }\n\n  addTerm(term) {\n    const context = this, ///\n          termA = term, ///\n          termString = term.getString();\n\n    context.trace(`Adding the '${termString}' term to the mnemic context...`);\n\n    const terms = this.getTerms(),\n          termB = terms.find((term) => {\n            const termB = term, ///\n                  termAComparesToTermB = termA.compareTerm(termB);\n      \n            if (termAComparesToTermB) {\n              return true;\n            }\n          }) || null;\n\n    if (termB !== null) {\n      context.trace(`The '${termString}' term has already been added to the mnemic context.`);\n    } else {\n      this.terms.push(term);\n    }\n\n    context.debug(`...added the '${termString}' term to the mnemic context.`);\n  }\n\n  addFrame(frame) {\n    const context = this, ///\n          frameA = frame, ///\n          frameString = frame.getString();\n\n    context.trace(`Adding the '${frameString}' frame to the mnemic context...`);\n\n    const frames = this.getFrames(),\n          frameB = frames.find((frame) => {\n            const frameB = frame, ///\n                  frameAEqualToFrameB = frameA.isEqualTo(frameB);\n      \n            if (frameAEqualToFrameB) {\n              return true;\n            }\n          }) || null;\n\n    if (frameB !== null) {\n      context.trace(`The '${frameString}' frame has already been added to the mnemic context.`);\n    } else {\n      this.frames.push(frame);\n    }\n\n    context.debug(`...added the '${frameString}' frame to the mnemic context.`);\n  }\n\n  addEquality(equality) {\n    const context = this, ///\n          equalityA = equality, ///\n          equalityString = equality.getString();\n\n    context.trace(`Adding the '${equalityString}' equality to the mnemic context...`);\n\n    const equalities = this.getEqualities(),\n          equalityB = equalities.find((equality) => {\n            const equalityB = equality, ///\n                  equalityAEqualToEqualityB = equalityA.isEqualTo(equalityB);\n      \n            if (equalityAEqualToEqualityB) {\n              return true;\n            }\n          }) || null;\n\n    if (equalityB !== null) {\n      context.trace(`The '${equalityString}' equality has already been added to the mnemic context.`);\n    } else {\n      this.equalities.push(equality);\n    }\n\n    context.debug(`...added the '${equalityString}' equality to the mnemic context.`);\n  }\n\n  addJudgement(judgement) {\n    const context = this, ///\n          judgementA = judgement, ///\n          judgementString = judgement.getString();\n\n    context.trace(`Adding the '${judgementString}' judgement to the mnemic context...`);\n\n    const judgements = this.getJudgements(),\n          judgementB = judgements.find((judgement) => {\n            const judgementB = judgement, ///\n                  judgementAEqualToEqualityB = judgementA.isEqualTo(judgementB);\n      \n            if (judgementAEqualToEqualityB) {\n              return true;\n            }\n          }) || null;\n\n    if (judgementB !== null) {\n      context.trace(`The '${judgementString}' judgement has already been added to the mnemic context.`);\n    } else {\n      this.judgements.push(judgement);\n    }\n\n    context.debug(`...added the '${judgementString}' judgement to the mnemic context.`);\n  }\n\n  addStatement(statement) {\n    const context = this, ///\n          statementA = statement, ///\n          statementString = statement.getString();\n\n    context.trace(`Adding the '${statementString}' statement to the mnemic context...`);\n\n    const statements = this.getStatements(),\n          statementB = statements.find((statement) => {\n            const statementB = statement, ///\n                  statementAEqualToStatementB = statementA.isEqualTo(statementB);\n      \n            if (statementAEqualToStatementB) {\n              return true;\n            }\n          }) || null;\n\n    if (statementB !== null) {\n      context.trace(`The '${statementString}' statement has already been added to the mnemic context.`);\n    } else {\n      this.statements.push(statement);\n    }\n\n    context.debug(`...added the '${statementString}' statement to the mnemic context.`);\n  }\n\n  addAssertion(assertion) {\n    const context = this, ///\n          assertionA = assertion, ///\n          assertionString = assertion.getString();\n\n    context.trace(`Adding the '${assertionString}' assertion to the mnemic context...`);\n\n    const assertions = this.getAssumptions(),\n          assertionB = assertions.find((assertion) => {\n            const assertionB = assertion, ///\n                  assertionAEqualToAssertionB = assertionA.isEqualTo(assertionB);\n      \n            if (assertionAEqualToAssertionB) {\n              return true;\n            }\n          }) || null;\n\n    if (assertionB !== null) {\n      context.trace(`The '${assertionString}' assertion has already been added to the mnemic context.`);\n    } else {\n      this.assertions.push(assertion);\n    }\n\n    context.debug(`...added the '${assertionString}' assertion to the mnemic context.`);\n  }\n\n  addReference(reference) {\n    const context = this, ///\n          referenceA = reference, ///\n          referenceString = reference.getString();\n\n    context.trace(`Adding the '${referenceString}' reference to the mnemic context...`);\n\n    const references = this.getReferences(),\n          referenceB = references.find((reference) => {\n            const referenceB = reference, ///\n                  referenceAEqualToReferenceB = referenceA.isEqualTo(referenceB);\n      \n            if (referenceAEqualToReferenceB) {\n              return true;\n            }\n          }) || null;\n\n    if (referenceB !== null) {\n      context.trace(`The '${referenceString}' reference has already been added to the mnemic context.`);\n    } else {\n      this.references.push(reference);\n    }\n\n    context.debug(`...added the '${referenceString}' reference to the mnemic context.`);\n  }\n\n  addAssumption(assumption) {\n    const context = this, ///\n          assumptionA = assumption, ///\n          assumptionString = assumption.getString();\n\n    context.trace(`Adding the '${assumptionString}' assumption to the mnemic context...`);\n\n    const assumptions = this.getAssumptions(),\n          assumptionB = assumptions.find((assumption) => {\n            const assumptionB = assumption, ///\n                  assumptionAEqualToAssumptionB = assumptionA.isEqualTo(assumptionB);\n      \n            if (assumptionAEqualToAssumptionB) {\n              return true;\n            }\n          }) || null;\n\n    if (assumptionB !== null) {\n      context.trace(`The '${assumptionString}' assumption has already been added to the mnemic context.`);\n    } else {\n      this.assumptions.push(assumption);\n    }\n\n    context.debug(`...added the '${assumptionString}' assumption to the mnemic context.`);\n  }\n\n  addMetavariable(metavariable) {\n    const context = this, ///\n          metavariableA = metavariable, ///\n          metavariableString = metavariable.getString();\n\n    context.trace(`Adding the '${metavariableString}' metavariable to the mnemic context...`);\n\n    const metavariables = this.getMetavariables(),\n          metavariableB = metavariables.find((metavariable) => {\n            const metavariableB = metavariable, ///\n                  metavariableAEqualToSubstitutionB = metavariableA.isEqualTo(metavariableB);\n      \n            if (metavariableAEqualToSubstitutionB) {\n              return true;\n            }\n          }) || null;\n\n    if (metavariableB !== null) {\n      context.trace(`The '${metavariableString}' metavariable has already been added to the mnemic context.`);\n    } else {\n      this.metavariables.push(metavariable);\n    }\n\n    context.debug(`...added the '${metavariableString}' metavariable to the mnemic context.`);\n  }\n\n  addSubstitution(substitution) {\n    const context = this, ///\n          substitutionA = substitution, ///\n          substitutionString = substitution.getString();\n\n    context.trace(`Adding the '${substitutionString}' substitution to the mnemic context...`);\n\n    const substitutions = this.getSubstitutions(),\n          substitutionB = substitutions.find((substitution) => {\n            const substitutionB = substitution, ///\n                  substitutionAEqualToSubstitutionB = substitutionA.isEqualTo(substitutionB);\n\n            if (substitutionAEqualToSubstitutionB) {\n              return true;\n            }\n          }) || null;\n\n    if (substitutionB !== null) {\n      context.trace(`The '${substitutionString}' substitution has already been added to the mnemic context.`);\n    } else {\n      this.substitutions.push(substitution);\n    }\n\n    context.debug(`...added the '${substitutionString}' substitution to the mnemic context.`);\n  }\n\n  addTerms(terms) {\n    terms.forEach((term) => {\n      this.addTerm(term);\n    });\n  }\n\n  addFrames(frames) {\n    frames.forEach((frame) => {\n      this.addFrame(frame);\n    });\n  }\n\n  addEqualities(equalities) {\n    equalities.forEach((equality) => {\n      this.addEquality(equality);\n    });\n  }\n\n  addJudgements(judgements) {\n    judgements.forEach((judgement) => {\n      this.addJudgement(judgement);\n    });\n  }\n\n  addAssertions(assertions) {\n    assertions.forEach((assertion) => {\n      this.addAssertion(assertion);\n    });\n  }\n\n  addStatements(statements) {\n    statements.forEach((statement) => {\n      this.addStatement(statement);\n    });\n  }\n\n  addReferences(references) {\n    references.forEach((reference) => {\n      this.addReference(reference);\n    });\n  }\n\n  addAssumptions(assumptions) {\n    assumptions.forEach((assumption) => {\n      this.addAssumption(assumption);\n    });\n  }\n\n  addMetavariables(metavariables) {\n    metavariables.forEach((metavariable) => {\n      this.addMetavariable(metavariable);\n    });\n  }\n\n  addSubstitutions(substitutions) {\n    ///\n  }\n\n  findVariableByVariableNode(variableNode) {\n    const variableIdentifier = variableNode.getVariableIdentifier(),\n          declaredVariable = this.findDeclaredVariableByVariableIdentifier(variableIdentifier),\n          variable = declaredVariable;  ///\n\n    return variable;\n  }\n\n  findTermByTermNode(termNode) {\n    const terms = this.getTerms(),\n          term = terms.find((term) => {\n            const termNodeMatches = term.matchTermNode(termNode);\n      \n            if (termNodeMatches) {\n              return true;\n            }\n          }) || null;\n\n    return term;\n  }\n\n  findFrameByFrameNode(frameNode) {\n    const frames = this.getFrames(),\n          frame = frames.find((frame) => {\n            const frameNodeMatches = frame.matchFrameNode(frameNode);\n\n            if (frameNodeMatches) {\n              return true;\n            }\n          }) || null;\n\n    return frame;\n  }\n\n  findEqualityByEqualityNode(equalityNode) {\n    const equalities = this.getEqualities(),\n          equality = equalities.find((equality) => {\n            const equalityNodeMatches = equality.matchEqualityNode(equalityNode);\n\n            if (equalityNodeMatches) {\n              return true;\n            }\n          }) || null;\n\n    return equality;\n  }\n\n  findJudgementByJudgementNode(judgementNode) {\n    const judgements = this.getJudgements(),\n          judgement = judgements.find((judgement) => {\n            const judgementNodeMatches = judgement.matchJudgementNode(judgementNode);\n\n            if (judgementNodeMatches) {\n              return true;\n            }\n          }) || null;\n\n    return judgement;\n  }\n\n  findStatementByStatementNode(statementNode) {\n    const statements = this.getStatements(),\n          statement = statements.find((statement) => {\n            const statementNodeMatches = statement.matchStatementNode(statementNode);\n\n            if (statementNodeMatches) {\n              return true;\n            }\n          }) || null;\n\n    return statement;\n  }\n\n  findReferenceByReferenceNode(referenceNode) {\n    const references = this.getReferences(),\n          reference = references.find((reference) => {\n            const referenceMatcheReferenceNode = reference.matchReferenceNode(referenceNode);\n\n            if (referenceMatcheReferenceNode) {\n              return true;\n            }\n          }) || null;\n\n    return reference;\n  }\n\n  findAssertionByAssertionNode(assertionNode) {\n    const assertions = this.getAssertions(),\n          assertion = assertions.find((assertion) => {\n            const assertionNodeMatches = assertion.matchAssertionNode(assertionNode);\n\n            if (assertionNodeMatches) {\n              return true;\n            }\n          }) || null;\n\n    return assertion;\n  }\n\n  findAssumptionByAssumptionNode(assumptionNode) {\n    const assumptions = this.getAssumptions(),\n          assumption = assumptions.find((assumption) => {\n            const assumptionNodeMatches = assumption.matchAssumptionNode(assumptionNode);\n\n            if (assumptionNodeMatches) {\n              return true;\n            }\n          }) || null;\n\n    return assumption;\n  }\n\n  findReferenceByMetavariableNode(metavariableNode) {\n    const references = this.getReferences(),\n          reference = references.find((reference) => {\n            const referenceMatcheMetavariableNode = reference.matchMetavariableNode(metavariableNode);\n\n            if (referenceMatcheMetavariableNode) {\n              return true;\n            }\n          }) || null;\n\n    return reference;\n  }\n\n  findMetavariableByMetavariableNode(metavariableNode) {\n    const metavariables = this.getMetavariables(),\n          metavariable = metavariables.find((metavariable) => {\n            const metavariableNodeMatches = metavariable.matchMetavariableNode(metavariableNode);\n\n            if (metavariableNodeMatches) {\n              return true;\n            }\n          }) || null;\n\n    return metavariable;\n  }\n\n  findSubstitutionBySubstitutionNode(substitutionNode) {\n    const substitutions = this.getSubstitutions(),\n          substitution = substitutions.find((substitution) => {\n            const substitutionNodeMatches = substitution.matchSubstitutionNode(substitutionNode);\n\n            if (substitutionNodeMatches) {\n              return true;\n            }\n          }) || null;\n\n    return substitution;\n  }\n\n  isTermPresentByTermNode(termNode) {\n    const term = this.findTermByTermNode(termNode),\n          termPresent = (term !== null);\n\n    return termPresent;\n  }\n\n  isFramePresentByFrameNode(frameNode) {\n    const frame = this.findFrameByFrameNode(frameNode),\n          framePresent = (frame !== null);\n\n    return framePresent;\n  }\n\n  isEqualityPresentByEqualityNode(equalityNode) {\n    const equality = this.findEqualityByEqualityNode(equalityNode),\n          equalityPresent = (equality !== null);\n\n    return equalityPresent;\n  }\n\n  isJudgementPresentByJudgementNode(judgementNode) {\n    const judgement = this.findJudgementByJudgementNode(judgementNode),\n          judgementPresent = (judgement !== null);\n\n    return judgementPresent;\n  }\n\n  isStatementPresentByStatementNode(statementNode) {\n    const statement = this.findStatementByStatementNode(statementNode),\n          statementPresent = (statement !== null);\n\n    return statementPresent;\n  }\n\n  isAssertionPresentByAssertionNode(assertionNode) {\n    const assertion = this.findAssertionByAssertionNode(assertionNode),\n          assertionPresent = (assertion !== null);\n\n    return assertionPresent;\n  }\n\n  isAssumptionPresentByAssumptionNode(assumptionNode) {\n    const assumption = this.findAssumptionByAssumptionNode(assumptionNode),\n          assumptionPresent = (assumption !== null);\n\n    return assumptionPresent;\n  }\n\n  isReferencePresentByMetavariableNode(metavariableNode) {\n    const reference = this.findReferenceByMetavariableNode(metavariableNode),\n          referencePresent = (reference !== null);\n\n    return referencePresent;\n  }\n\n  isMetavariablePresentByMetavariableNode(metavariablenNode) {\n    const metavariablen = this.findMetavariableByMetavariableNode(metavariablenNode),\n          metavariablenPresent = (metavariablen !== null);\n\n    return metavariablenPresent;\n  }\n\n  isSubstitutionPresentBySubstitutionNode(substitutionNode) {\n    const substitution = this.findSubstitutionBySubstitutionNode(substitutionNode),\n          substitutionPresent = (substitution !== null);\n\n    return substitutionPresent;\n  }\n\n  commit(element) {\n    const context = this; ///\n\n    element.setContext(context);\n  }\n\n  initialise(json) {\n    const context = this; ///\n\n    this.terms = termsFromJSON(json, context);\n\n    this.metavariables = metavariablesFromJSON(json, context);\n\n    this.statements = statementsFromJSON(json, context);\n    this.references = referencesFromJSON(json, context);\n\n    this.equalities = equalitiesFromJSON(json, context);\n    this.assumptions = assumptionsFromJSON(json, context);\n\n    this.frames = framesFromJSON(json, context);\n\n    this.judgements = judgementsFromJSON(json, context);\n    this.assertions = assertionsFromJSON(json, context);\n    this.substitutions = substitutionsFromJSON(json, context);\n  }\n\n  toJSON() {\n    let terms = this.getTerms(),\n        frames = this.getFrames(),\n        judgements = this.getJudgements(),\n        equalities = this.getEqualities(),\n        statements = this.getStatements(),\n        assertions = this.getAssertions(),\n        references = this.getReferences(),\n        assumptions = this.getAssumptions(),\n        metavariables = this.getMetavariables(),\n        substitutions = this.getSubstitutions();\n\n    const termsJSON = termsToTermsJSON(terms),\n          framesJSON = framesToFramesJSON(frames),\n          judgementsJSON = judgementsToJudgementsJSON(judgements),\n          equalitiesJSON = equalitiesToEqualitiesJSON(equalities),\n          statementsJSON = statementsToStatementsJSON(statements),\n          assertionsJSON = assertionsToAssertionsJSON(assertions),\n          referencesJSON = referencesToReferencesJSON(references),\n          assumptionsJSON = assumptionsToAssumptionsJSON(assumptions),\n          metavariablesJSON = metavariablesToMetavariablesJSON(metavariables),\n          substitutionsJSON = substitutionsToSubstitutionsJSON(substitutions);\n\n    terms = termsJSON; ///\n    frames = framesJSON; ///\n    judgements = judgementsJSON; ///\n    equalities = equalitiesJSON; ///\n    statements = statementsJSON; ///\n    assertions = assertionsJSON; ///\n    references = referencesJSON; ///\n    assumptions = assumptionsJSON; ///\n    metavariables = metavariablesJSON;  //\n    substitutions = substitutionsJSON; ///\n\n    const json = {\n      terms,\n      frames,\n      judgements,\n      equalities,\n      statements,\n      assertions,\n      references,\n      assumptions,\n      metavariables,\n      substitutions\n    };\n\n    return json;\n  }\n\n  static fromJSON(json, context) {\n    const terms = null,\n          frames = null,\n          equalities = null,\n          judgements = null,\n          statements = null,\n          assertions = null,\n          references = null,\n          assumptions = null,\n          metavariables = null,\n          substitutions = null,\n          mnemicContext = new MnemicContext(context, terms, frames, equalities, judgements, assertions, statements, references, assumptions, metavariables, substitutions);\n\n    mnemicContext.initialise(json);\n\n    return mnemicContext;\n  }\n\n  static fromNothing(context) {\n    const terms = [],\n          frames = [],\n          equalities = [],\n          judgements = [],\n          statements = [],\n          assertions = [],\n          references = [],\n          assumptions = [],\n          metavariables = [],\n          substitutions = [],\n          mnemicContext = new MnemicContext(context, terms, frames, equalities, judgements, assertions, statements, references, assumptions, metavariables, substitutions);\n\n    return mnemicContext;\n  }\n}\n"],"names":["MnemicContext","push","arrayUtilities","Context","context","terms","frames","equalities","judgements","assertions","statements","references","assumptions","metavariables","substitutions","getTerms","getContext","compressTerms","getFrames","compressFrames","getEqualities","compressEqualities","getJudgements","compressJudgements","getStatements","compressStatements","getAssertions","compressAssertions","getReferences","compressReferences","getAssumptions","compressAssumptions","getMetavariables","compressMetavariables","getSubstitutions","compressSubstitutions","addTerm","term","termA","termString","getString","trace","termB","find","termAComparesToTermB","compareTerm","debug","addFrame","frame","frameA","frameString","frameB","frameAEqualToFrameB","isEqualTo","addEquality","equality","equalityA","equalityString","equalityB","equalityAEqualToEqualityB","addJudgement","judgement","judgementA","judgementString","judgementB","judgementAEqualToEqualityB","addStatement","statement","statementA","statementString","statementB","statementAEqualToStatementB","addAssertion","assertion","assertionA","assertionString","assertionB","assertionAEqualToAssertionB","addReference","reference","referenceA","referenceString","referenceB","referenceAEqualToReferenceB","addAssumption","assumption","assumptionA","assumptionString","assumptionB","assumptionAEqualToAssumptionB","addMetavariable","metavariable","metavariableA","metavariableString","metavariableB","metavariableAEqualToSubstitutionB","addSubstitution","substitution","substitutionA","substitutionString","substitutionB","substitutionAEqualToSubstitutionB","addTerms","forEach","addFrames","addEqualities","addJudgements","addAssertions","addStatements","addReferences","addAssumptions","addMetavariables","addSubstitutions","findVariableByVariableNode","variableNode","variableIdentifier","getVariableIdentifier","declaredVariable","findDeclaredVariableByVariableIdentifier","variable","findTermByTermNode","termNode","termNodeMatches","matchTermNode","findFrameByFrameNode","frameNode","frameNodeMatches","matchFrameNode","findEqualityByEqualityNode","equalityNode","equalityNodeMatches","matchEqualityNode","findJudgementByJudgementNode","judgementNode","judgementNodeMatches","matchJudgementNode","findStatementByStatementNode","statementNode","statementNodeMatches","matchStatementNode","findReferenceByReferenceNode","referenceNode","referenceMatcheReferenceNode","matchReferenceNode","findAssertionByAssertionNode","assertionNode","assertionNodeMatches","matchAssertionNode","findAssumptionByAssumptionNode","assumptionNode","assumptionNodeMatches","matchAssumptionNode","findReferenceByMetavariableNode","metavariableNode","referenceMatcheMetavariableNode","matchMetavariableNode","findMetavariableByMetavariableNode","metavariableNodeMatches","findSubstitutionBySubstitutionNode","substitutionNode","substitutionNodeMatches","matchSubstitutionNode","isTermPresentByTermNode","termPresent","isFramePresentByFrameNode","framePresent","isEqualityPresentByEqualityNode","equalityPresent","isJudgementPresentByJudgementNode","judgementPresent","isStatementPresentByStatementNode","statementPresent","isAssertionPresentByAssertionNode","assertionPresent","isAssumptionPresentByAssumptionNode","assumptionPresent","isReferencePresentByMetavariableNode","referencePresent","isMetavariablePresentByMetavariableNode","metavariablenNode","metavariablen","metavariablenPresent","isSubstitutionPresentBySubstitutionNode","substitutionPresent","commit","element","setContext","initialise","json","termsFromJSON","metavariablesFromJSON","statementsFromJSON","referencesFromJSON","equalitiesFromJSON","assumptionsFromJSON","framesFromJSON","judgementsFromJSON","assertionsFromJSON","substitutionsFromJSON","toJSON","termsJSON","termsToTermsJSON","framesJSON","framesToFramesJSON","judgementsJSON","judgementsToJudgementsJSON","equalitiesJSON","equalitiesToEqualitiesJSON","statementsJSON","statementsToStatementsJSON","assertionsJSON","assertionsToAssertionsJSON","referencesJSON","referencesToReferencesJSON","assumptionsJSON","assumptionsToAssumptionsJSON","metavariablesJSON","metavariablesToMetavariablesJSON","substitutionsJSON","substitutionsToSubstitutionsJSON","fromJSON","mnemicContext","fromNothing"],"mappings":"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"}